typescript 类

冷不防 2021-07-24 15:40 452阅读 0赞

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}
    	
    链式调用
    	通过方法返回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');
        }
    }