TypeScript的类

1. 类的定义

TypeScript中的类和ES6中类的定义类似，但是也有区别

class Person {
  name: string; // 和JAVA类似,要先在这声明对象中拥有的属性和类型,这里的分号很重要
  /*
    该属性定义相当于public name:string;
    只不过省略了public,下面再做解释
  */
  constructor(n: string) {
    this.name = n; // 和ES6一样,传入构造函数,只不过需要在前面先定义this的属性
  }

  run(): void {
    console.log(this.name);
  }
}

let p: Person = new Person("张三"); // 可以对实例类型变量进行类型的定义,也可以默认不写为any
let Person2: typeof Person = Person; // 把Person类赋值Person2
// typeof Person是表明该对象是一个Person类的类型,而不是Person的实例类型
let p2: Person = new Person2('tt'); // 因为Person2也是Person类型的类,所以可以这样实例对象
p.age = 18; // 报错,类只允许有name属性
p.run(); // 张三

对象属性设置的时候需要在后面打上分号表示结尾，不像JS中对象写法

constructor函数后面不能加上返回值的修辞符，否则会报错，可以看作是固定写法

函数定义完成后不需要加上符号分割

---

2. 类的继承

类的继承和接口不同，一个类只能继承一个父类

class Person {
  name: string;
  constructor(n: string) {
    this.name = n;
  }
  run(): void {
    console.log(this.name);
  }
}

class Student extends Person { // 类的继承可以说和ES6完全一样,只是constructor需要指定类型
  age: number;
  constructor(name: string, age: number) {
    super(name);
    this.age = age;
  }
  work() {
    console.log(this.age);
  }
}
let s = new Student("李四", 18);
s.run();
s.work(); // 18

如果子类里的方法和父类方法名一致，那么在使用的时候会使用子类的方法，不会使用父类的方法了

---

3. 类的修辞符

在TypeScript中定义属性或方法的时候为我们提供了四种修辞符

• public：公有类型，在类、子类、类外部都可以对其访问

  这里的在类外部访问就是在实例化过后能在类的外界单独打印该属性，而不是只在内部的方法中使用该属性

• protected： 保护类型，在类、子类里可以对其进行访问，但是在类的外部无法进行访问

• private：私有类型，在类里面可以访问，在子类和类的外部都无法访问

  • TypeScript使用的是结构性类型系统，当我们比较两种不同的类型时，并不在乎它们从何处而来，如果所有成员的类型都是兼容的，我们就认为它们的类型是兼容的
  • 当我们比较带有 private或 protected成员的类型的时候，如果其中一个类型里包含一个private成员，那么只有当另外一个类型中也存在这样一个 private成员，并且它们都是来自同一处声明时，我们才认为这两个类型是兼容的。对于 protected成员也使用这个规则

  class Animal {
    private name: string;
    constructor(theName: string) { this.name = theName; }
  }
  
  class Rhino extends Animal {
    constructor() { 
      super("Rhino"); 
    }
  }
  
  class Employee {
    private name: string;
    constructor(theName: string) { this.name = theName; }
  }
  
  let animal = new Animal("Goat");
  let rhino = new Rhino();
  let employee = new Employee("Bob");
  
  animal = rhino; // 能够赋值,因为两者兼容,都是同一个私有属性name
  

animal = employee; // 错误: Animal 与 Employee 不兼容,name的私有属性不兼容

`readonly`：只读类型，可以使用 `readonly`关键字将属性设置为只读的,。只读属性必须在声明时或构造函数里被初始化

```typescript
class Octopus {
  readonly name: string;
  readonly numberOfLegs: number = 8;
  constructor(theName: string) {
    this.name = theName;
  }
}

let dad = new Octopus("Man with the 8 strong legs");
dad.name = "Man with the 3-piece suit"; // 错误! name 是只读的.

如果属性不添加修饰符，默认为公有属性(public)

// public
class Person {
  public name: string;
  constructor(n: string) {
    this.name = n;
  }
  public run(): void {
    console.log(this.name);
  }
}

class Student extends Person {
  constructor(name: string) {
    super(name);
  }
}
let s = new Student("李四");
console.log(s.name); // 李四
s.run(); // 李四

// protected
class Person {
  protected name: string;
  constructor(n: string) {
    this.name = n;
  }
  public run(): void { // 如果这个方法是protected,下面的s.run()也会报错
    console.log(this.name);
  }
}

class Student extends Person {
  constructor(name: string) {
    super(name);
  }
}
let s = new Student("李四");
console.log(s.name); // 报错
s.run(); // 李四

如果构造函数也可以被标记成 protected，意味着这个类不能在包含它的类外被实例化，但是能被继承

class Person {
  protected name: string;
  protected constructor(theName: string) { this.name = theName; }
}
// Employee 能够继承 Person
class Employee extends Person {
  private department: string;

  constructor(name: string, department: string) {
    super(name);
    this.department = department;
  }

  public getElevatorPitch() {
    return `Hello, my name is ${this.name} and I work in ${this.department}.`;
  }
}
let howard = new Employee("Howard", "Sales");
let john = new Person("John"); // 错误:因为'Person' 的构造函数是被保护的.

// private
class Person {
  private name: string;
  constructor(n: string) {
    this.name = n;
  }
  run(): void {
    console.log(this.name);
  }
}

class Student extends Person {
  constructor(name: string) {
    super(name);
  }
  work(): void {
    console.log(this.name);
  }
}
let s = new Student("李四");
console.log(s.name); // 报错
s.work(); // 报错
s.run(); // 李四,因为run方法是Person内部的,可以使用私有属性

参数属性

参数属性通过给构造函数参数前面添加一个访问限定符来声明。 使用 private限定一个参数属性会声明并初始化一个私有成员，对于 public和 protected来说也是一样

总的来说，这种写法是上面先声明又赋值属性的简便写法，可以直接通过这种写法改写上方先先在前面声明属性的写法，构造函数中也可以什么都不写

• 声明了一个构造函数参数及其类型

• 声明了一个同名的公共属性

• 当我们 new出该类的一个实例时，把该属性初始化为相应的参数值

  class Octopus {
    readonly numberOfLegs: number = 8;
    constructor(readonly name: string) { // 通过这种写法改变上面对应readonly的例子
    }
  }
  

---

4. 寄存器

TypeScript中也可以对一个属性时用get和set方法对一个属性内部的获取和赋值进行拦截

let passcode = "secret passcode";

class Employee {
  private _fullName: string;
  get fullName(): string { // 对fullName属性进行拦截
    return this._fullName;
  }
  set fullName(newName: string) {
    if (passcode && passcode == "secret passcode") {
      this._fullName = newName;
    } else {
      console.log("Error: Unauthorized update of employee!");
    }
  }
}

let employee = new Employee();
employee.fullName = "Bob Smith";
if (employee.fullName) {
  alert(employee.fullName);
}

只带有 get不带有 set的存取器自动被推断为readonly类型的属性

---

5. 静态方法和属性

class Person {
  public name: string;
  constructor(n: string) {
    this.name = n;
  }
  run(): void {
    console.log(this.name);
  }
}

class Student extends Person {
  static name1: string; // 设置静态属性
  constructor(name: string) {
    super(name);
    Student.name1 = this.name; // 赋值
  }
  static work(): void { // 静态方法
    console.log(Student.name1);
  }
  work(): void {
    console.log(Student.name1);
  }
}
let s = new Student("李四");
console.log(Student.name1); // 李四
Student.work();
s.work(); // 李四

---

6. 抽象类

TypeScript中的抽象类是提供其他类继承的基类，不能直接被实例化，只能被其他类所继承

用abstract关键字定义抽象类和抽象类中的抽象方法或属性，抽象类中的抽象方法不包含具体实现，但是必须要在派生类，也就是继承的类中实现抽象方法，抽象属性不需要赋值，并且继承的类不能够扩展自己的方法和属性

总的来说，抽象类和抽象方法只是用来定义一个标准，而在其子类在必须要实现这个标准，并且不能扩展抽象类中没有的标准。否则会报错

用abstract声明的抽象方法只能放在抽象类中。否则会报错

abstract class Department {
  abstract age: number;
  constructor(public name: string) { // 参数属性的一个应用
  }

  printName(): void {
    console.log('Department name: ' + this.name);
  }

  abstract printMeeting(): void; // 必须在派生类中实现
}

class AccountingDepartment extends Department {
  public age: number = 18;
  constructor() {
    super('Accounting and Auditing'); // 在派生类的构造函数中必须调用 super()
  }
  printMeeting(): void {
    console.log('The Accounting Department meets each Monday at 10am.');
  }
  generateReports(): void {
    console.log('Generating accounting reports...');
  }
}

let department: Department; // 允许创建一个对抽象类型的引用
department = new Department(); // 错误: 不能创建一个抽象类的实例
department = new AccountingDepartment(); // 允许对一个抽象子类进行实例化和赋值
console.log(department.age); // 18
department.printName();
department.printMeeting();
department.generateReports(); // 错误: 方法在声明的抽象类中不存在