class

声明 和 实例化

//类相当于你设定的一个流水线，他能够实现一个产品，你可以设定这个产品具有那些用法，那些属性

//实例化相当于你用该流水线制造了一个产品他具有该类中的所有用法，和属性

//构造函数是你制造产品时候，可以设定一些出厂设置

//声明
class Person{
  //类中的属性
  age:number
  gender:string

  
  //构造函数  用于初始化类中属性值
  constructor(age:number,gender:string){
    //构造函数没有返回值
    //通过this获取person中的数据
    //通过实例化时候，传递的两个参数，初始化Person类里面的值
    this.age=age
    this.gender = gender
  }
  
  //类中的方法
  scale(n:number){
    this.age=n
  }
  
}

//实例化
let p = new Person( 12,"男")

//用实例调用类中的方法
p.scale(10)

class 的继承 extends

//一个类通过继承可以获取另一个类中的属性和方法

class A1{
  x=1
  y=2
  move(){
  console.log(this.x)
  }
}

//继承A1  并添加一些新的属性方法
class A2  extends A1{
  name="我是A2中的属性"
  move2(){
  console.log("我是A2中的方法")
  }
}

//实例化A2
let a = new A2()
a.move()//调用的A1中的方法

a.move2()//调用A2中的方法

类型实现接口 implements

//通过implements 关键字让class实现接口
//类实现接口后，意为着，该类必须提供接口中指定的所有方法和属性
//就是用接口来约束该类有那些东西


//创建一个接口
interface Singable{
	sing(){
		
	}
}

//创建一个类
class Person implements Singable{
	sing(){
		console.log("你好呀")
	}
}

类的权限修饰符

//控制类中的属性或方法   在每个地方的使用权限

//  public     公有的谁都可以使用   默认省略不写
//  protected  受保护的  子类方法可以使用  实例对象不能使用
//  private    私有的

//readonly     只读修饰符   用来防止构造函数之外对属性进行赋值
//明确 类型
//只能修饰属性  不能修饰方法
//接口或者{} 表示的对象类型  也可以使用readonly
interface  Jie{
reddonly name:string
}

let obj:Jie={
name:"张三"
}

obj.name="李四"//会出错的




//使用方式
class Person {
  
  readonly age:number =18//他只能在constructor中调用
  //readonlu age=18   那么age的类型为18（字面量类型）
  
  constructor(age:number){
    this.age=age
  }
  
  public name="我是公有的属性"
  public move(){
  console.log("我是公有的方法，谁都能调用")
  }
  
  protected si(){
  console.log("子类可以调用，实例对象不行")
  }
  
  private   siyou(){
  console.log("子类和实例对象都不能调用")
  }
}

//继承
class  Person1 extends Person{
 bark(){
   this.move()
   this.si()
 }
}

//创建实例

let a = new Person()
a.move()

兼容性问题

兼容性介绍

//编程语言中有两种类型系统
//结构化类型系统   ts
//标明类型系统  C#  java

//结构化类型就是 两个类中的属性，方法完全一样，那么他会被默认为同一个类
class Point{
	x:number;
	y:number
}

class Point2{
	x:number;
	y:number
}

//这里p的类型为Point  但是他却能接收Point2的实例，说明他俩被认为同一个类
const p:Point = new Point2()

对象之间的类型兼容性

//对象一和对象二中的值一样，那么他俩会被认为同一个
//如果对象一，不仅具有对象二中的所有属性，且比对象二还多，对象一同样可以赋值给对象二
class Point{
	x:number;
	y:number
}

class Point2{
	x:number;
	y:number
  z:number
}

const p:Point = new Point2()

接口之间的兼容和类的一样，接口和类之间也能互相兼容

函数之间的兼容

//函数的兼容 有参数  数量  类型  返回值三者决定的

//参数的数量  少的能赋值给多的   和类正好相反
//参数的类型  同位置的参数类型要一样，或者兼容  
  参数为基础类型 那么要类型一样，  如果参数为对象或接口，那么要参数少的可以赋值给参数多的
//返回值  原始类型要一样  ，返回值为对象，那么就多的赋值少的
  
  
 //只有参数是少赋值给多（为了简写参数），其他都是多赋值给少的，
  
  let obj={name:number,age:number}
  let obj1={name:number}
  
  function fun(p:obj){}
  function fun1(p:obj1){}

  fun=fun1