typescript 类

class 类名{
	public readonly 属性名称:string
	public 名称?:string		?可选属性
	public static 声明静态属性
		其中:
			readonly修饰的属性,必须在声明时或构造函数里被初始化,即可以在构造函数中被修改。 
			private:只能在类中被调用,不能在实例和派生类中调用
				给constructor添加private表示该类不能被显示new实例化和继承
			protected:只能在类和派生类中调用,不能在该类的实例中调用
				给constructor添加protected表示该类只能被继承,相当于声明一个基类
			
	构造函数
		方式一
			constructor:(属性:类型)
			{
				this.属性=属性
			}
			
		方式二
			将属性定义和构造器合并,则使用了修饰符的属性(包括readonly修饰的)会被绑定到this上
			constructor(public 属性:类型,readonly 属性:类型){}
	
	getter和setter
	 使得类外可以调用私有属性和方法
		getter:
			get x():返回类型			不能有参数
			{
				return this.xx
			}
			调用:实例对象.x
		setter
			set x(xx:类型)   只能具有一个参数,且类型必须和get的返回类型一致
			{
				this.xx=xx
			}
			调用:实例对象.x=xx
		
}

抽象类,继承类来实现,继承类重写必须满足抽象类中的类型约束的抽象属性和抽象方法
	abstract class 类名{
		abstract 属性:类型			抽象属性
		abstract 方法名():返回类型; 	抽象方法
		可以有普通方法和变量
		setter和getter抽象方法,子类需要实现对应的set/get方法或声明x属性
			abstract set x(value:类型);	
			abstract get x():类型
	}
	其中:
		抽象类不能被实例化,若用作约束类型,只能使用抽象类中的方法
		通过this或实例对象来调用抽象类中的普通方法或属性
	
实现接口约束
	接口检测的是类的实例属性,如果通过静态属性实现,并不能符合
	interface x{
		属性:类型,
		函数名():返回约束
		...
	}
	
	class X implements x{
		必须实现接口中的除了非必要属性以外的属性,以及实现的属性不能用private和protected修饰,因为接口中的属性是公有的
	}
	
	class X implements x,x2{	接口可以实现多个
		必须实现接口中的除了非必要属性以外的属性,以及实现的属性不能用private和protected修饰,因为接口中的属性是公有的
	}
	
	let y:x=new X();
	let y:X=new X();
			
继承
	class X extends XX{
		...
		super(参数);     必须调用父类构造器
		super.方法名()/属性;  调用父类属性,一般用于重写的父类方法中继续使用父类方法
		this.父类方法名()/属性同样能访问(若未重写)
	}
	如果继承的类是泛型类,需要实现泛型或者扩展泛型
		实现泛型:
			class X extends XX<类型>{...}
		扩展泛型:
			class X<T> extends XX<T>{...}
	
类约束(当两个类的内部实现一样时,即便声明了类型可以进行赋值)
	class Foo {
	  x!: number;
	  constructor() {
	    
	  }
	}
	let a: Foo = {x:2}			当无typeof时,需要实现类的属性等
	let b:typeof Foo=class{...}	当有typeof时,类返回的是构造函数
	
链式调用
	通过方法返回this能实现链式调用

和接口声明合并,会添加到类的原型上
	class F{}	也可以是同名方法、变量
	interface F {	会为类添加一个name属性
	  name:string
	}
	const f = new F();
	f.name;

代码示例；

//static
class An{
    static is(a){
        return 1
    }
}

An.is(2);

class Dog{
    static age=20;
}
let age:number=Dog.age;

class Cat{
    a=1;
    private b=1;
    constructor(){
        this.a=1;
        this.b=2;
    }
}

class Mer{
    private name;
    public constructor(name){
        this.name=name;
    }
}

let mer=new Mer('橘猫');

class Lanmao{
    protected name;
    public constructor(name){
        this.name=name;
    }
}
//继承
class Xiaomao extends Lanmao{
    constructor(name){
        super(name);
        console.log(this.name);
    }
}

//抽象类,只能用于继承
abstract class Pink{
    public name;
    constructor(name){
        this.name=name;
    }
    //抽象类中的函数也是抽象函数
    public abstract sayhi();
}

class Black extends Pink{
    sayhi(){
        console.log('hello');
    }
}