基本用法

  1. class Animal{
  2.     public name:string;
  3.   public constructor(theName:string){
  4.       this.name = theName;
  5.   }
  6.   protected move(distance:number){
  7.       console.log(`${this.name} 移动了 ${distance}米`)
  8.   }
  9. }

配置项strictPropertyInitialization:false可以不严格设定初始值

类的注解

super在constructor外相当于父类本身
super在constructor内相当于父类的constructor

  1. class Dog extends Animal{
  2.     public name:string;
  3.   public constructor(theName2:string){
  4.       super(theName2)
  5.     //super相当于构造函数本身，这里会把对应的构造参数传给父类，继承对应的属性
  6.   }
  7.   protected move(distance:number=5 ){
  8.     super.move(distance)
  9.     //相当于Dog继承父类的move方法，会把对应的数据传过去
  10.   }
  11. }
  13. let dog = new Dog('my name is dog')
  14. dog.move()

这样dog的prototype上也有move方法，当class Dog extends Animal去掉protected move时，Dog的原型没有次方法，Dog的原型的原型Animal有move方法

类修饰符

  1. public
  2. 1.自身调用
  3. 2.子类调用
  4. 3.实例调用
  6. protected
  7. 1.自身调用
  8. 2.子类调用
  10. private
  11. 1.自身调用
  13. static
  14. 静态属性
  15. 只能通过调用class类来调用方法，无法创建实体类

readonly

不能出现在方法前，只能出现在属性前

  1. class Animal{
  2.     public readonly name:string;
  3.   public constructor(theName:string){
  4.       this.name = theName;
  5.   }
  6. }
  8. let a = new Animal('dongwu')
  9. a.name = 'change'//报错不能改写

简写

  1. class Animal{
  2.   constructor(private name:string){}
  3. }
  4. 相当于
  5. class Animal{
  6.     private name:string;
  7.   constructor(name:string){
  8.       this.name = name;
  9.   }
  10. }

存取器

getter setter
通过函数改变读取赋值行为

  1. class Employee{
  2.     private _fullName:string = 'node.js';
  3.     get name(){
  4.       return 'my name is' + this._fullName;
  5.   }
  6.     set name(newName:string){
  7.       if(passcode){
  8.        this._fullName = newName;
  9.     }else{
  10.       return 'unauthorized'
  11.     }
  12.   }
  13. }
  15. let e = new Employee()
  16. console.log(e.name) // my name is node.js

静态属性

非静态属性

所有没有加static的成员都是非静态成员，而类被实例化后，可以通过实例化的类名进行访问.非静态成员的生存期决定于该类的生存期，而静态成员不存在生产期的问题，因为它始终驻留在内存

  1. class Grid{
  2.     static origin = {x:1,y:2}
  3.     move(){
  4.       let x = Grid.origin.x 静态方法使用Grid.origin调用
  5.     return x
  6.   }
  7. }

抽象类

  1. 能够提供其他类的基类
  2. 无法创建实例
  3. 抽象方法一定要有实现 ``javascript abstract class Person{ constructor(public name:string){} say(){ console.log(i can say my${this.name}`) } abstract sayLanguage():void; //声明了抽象方法，子类必须声明此方法 }

class Blackman extends Person{ constructor(){ super(‘blackmanName’) } sayLanguage(){ //声明父类要求的抽象方法 console.log(‘say …’) } fight(){ console.log(‘fight’) } }

let zhijiage:Person; zhijiage = new Person(‘zhi’);//报错，抽象类不能实例化 zhijiage = new Blackman(‘zhi’); zhijiage.sayLanguage(); zhijiage.fight();//报错，因为不符合抽象类，去掉21行即不报错

  1. <a name="yiVKt"></a>
  2. ### 高阶
  4. 1. 定义类时，定义了一个类型
  5. 1. 定义类时，定义了一个构造函数
  6. 1. 接口可以继承
  7. ```javascript
  8. class Greeter{
  9.     x:number;
  10. }
  11. let g:typeof Greeter = Greeter;
  13. typeof Greeter为构造函数类型
  14. g为一个类

可以把类当作接口使用

  1. interface I extends Greeter{
  2.     y:number;
  3. }
  5. let a:I = {x:1,y:2};