TypeScript中的类

一、定义基本类

声明一个Person类，通过 new 实例化 Person 即可使用类中的属性和方法。要注意的是类型首字母必须大写。

class Soldier {
  public name: string;
  constructor(name: string) {
      this.name = name;
  }
  getInfo(): void {
      console.log(this.name); //don
  }
};

let don = new Soldier('don');
don.getInfo();

二、类的继承

TypeScript中类的继承需要通过extends来配合super来实现。子类若要继承父类的属性和方法需要执行一次super()，它代表实例化父类的构造函数，super() 只能用在子类的构造函数之中，用在其他地方就会报错。

//父类Soldier 
class Soldier {
  public name: string;
  constructor(name: string) {
      this.name = name;
  }
};
//子类Navy
class Navy extends Soldier {
  public age: number;
  constructor(name:string,age:number){
    super(name);
    this.age = age;
  }
  getInfo(): void {
      console.log(this.name); //don
      console.log(this.age); //18
  }
}

let don = new Navy('don', 18);
don.getInfo();

三、类的静态方法和属性

在类中通过static来定义类里的静态属性和静态方法，静态属性和静态方法属于类自身，而不属于实例，访问的时候要用类名访问，而不能用实例对象访问。

class Soldier {
  static country = "中国";
  constructor(){
    Soldier.getInfo();
  }
  static getInfo(){
    console.log(this.country); //报错
    console.log(Soldier.country); //中国
  }
}
let Don = new Soldier();
console.log(Don);

四、类里面的修饰符

TypeScript定义属性的时候给我们提供了三种修饰符：

• public：公有属性，在当前类里面、 子类 、类外面都可以访问。属性如果不加修饰符默认就public。
• protected：保护类型，在当前类里面、子类里面可以访问 ，在类外部没法访问。
• private：私有属性，在当前类里面可以访问，子类、类外部都没法访问。

我们先声明一个父类Soldier和子类Navy，在父类中声明了三个属性，公有属性country，保护类型name和私有属性sex。

//父类Soldier 
class Soldier {
  private sex:string;
  public country:string = '中国';
  protected name:string;
  constructor(name:string){
    this.name = name;
  }
}

//子类Navy
class Navy extends Soldier {
  constructor(name:string){
    super(name);
  }
  getInfo(){
    console.log(this.sex); //Property 'sex' is private and only accessible within class 'Soldier'
    console.log(this.country); //中国
    console.log(this.name); //don
  }
}

let don = new Navy("don");
don.getInfo();

上例中，是在子类里面访问了这三个属性，发现私有属性sex报错了，因为私有属性只能在当前的类中访问，接着再尝试在外部访问这三个属性。

let don = new Navy("don");
console.log(don.sex); //Property 'sex' is private and only accessible within class 'Soldier'.
console.log(don.name); //Property 'name' is protected and only accessible within class 'Soldier'
console.log(don.country); //中国

外部访问的话只有公有属性country可以访问。

五、抽象类

抽象类就是定义一个类的标准，让子类来实现。
首先声明一个抽象类Soldier，里面声明一个getInfo的抽象方法。

abstract class Soldier {
  abstract getInfo():void;
};

abstract抽象方法只能放在抽象类里面，不然会报错。

class Soldier { //Abstract methods can only appear within an abstract class
  abstract getInfo():void;
};

TypeScript中的抽象类是提供其它类的基类，不能直接被实例化。

abstract class Soldier {
  abstract getInfo():void;
};
let don = new Soldier(); //Cannot create an instance of an abstract class

抽象类和抽象方法都是用来定义标准的，抽象类的子类必须实现抽象类里面的抽象方法，就是说抽象类Soldier里面既然声明了抽象方法getInfo，那么派生类里面必须包含getInfo的方法。

//抽象类
abstract class Soldier {
  abstract getInfo():void;
};
//派生类
class Navy extends Soldier {
  getInfo(): void {
      console.log("测试"); //测试
  }
};

这里类似多态的实现思想，父类定义一个方法不去实现，让继承它的子类去实现，每一个子类有不同的表现，用abstract关键字定义的抽象方法和抽象类，需要让子类来实现。