1. 类的成员变量、成员方法，静态变量、静态方法、构造函数、实例化对象

// 创建类
class Student {
  // 成员变量
  name: string;
  age: number;
  // 静态变量
  static other: string = "我是静态的变量，不常改变";

  // 构造函数
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  // 成员方法
  play(ball: string): void {
    console.log(this.name + "在玩" + ball);
  }

  // 静态方法
  static say(word: string): void {
    console.log(this.other + "在说" + word);
  }
}

// 创建类的实例化对象，通过实例对象来调用成员方法和变量
let alias = new Student("alias", 18);
alias.play("棒球");
console.log(alias.name);

// 通过类的名称直接调用静态方法和属性，注意：静态方法只能调用静态变量
Student.say("hello world");
console.log(Student.other);

2. 类的继承

1.单继承

// 父类
class Person {
  public name: string;
  constructor(name: string) {
    this.name = name;
  }
  // 成员方法
  play(ball: string): void {
    console.log(ball);
  }
}

// 子类
class Student extends Person {
  public grade: string;

  constructor(name: string, grade: string) {
    super(name); // super 引用父类的构造函数
    this.grade = grade;
  }

  // 方法重写：子类方法名和父类相同，将重写父类方法
  play(ball: string): void {
    console.log(this.name + "在玩" + ball);
  }
}

const alias = new Student("alias", "一年级");
console.log(alias);
alias.play("篮球");

2.多继承

需要注意的是在 ts 中，子类只能继承一个父类，不可多继承，但是接口可以实现多继承

// Person1和Person2可以是接口，但不能是类
class Student extends Person1, Person2 {}

方式一：多重继承
TypeScript 不支持继承多个类，但支持多重继承

// 父类1
class Person1 {
  public name: string;
  constructor(name: string) {
    this.name = name;
  }
  play(ball: string): void {
    console.log(ball);
  }
}

// 父类2 继承 父类1
class Person2 extends Person1 {
  public age: number;
  constructor(name: string, age: number) {
    super(name); // super 引用父类的构造函数
    this.age = age;
  }
  study(say: string): void {
    console.log(this.name + say);
  }
}

// 子类 继承 父类2
class Student extends Person2 {
  public grade: string;

  constructor(name: string, age: number, grade: string) {
    super(name, age); // super 引用父类的构造函数
    this.grade = grade;
  }

  // 方法重写：子类方法名和父类相同，将重写父类方法
  play(ball: string): void {
    console.log(this.name + "在玩" + ball);
  }
}

const alias = new Student("alias", 8, "一年级");
console.log(alias);
alias.play("篮球");
alias.study("说：你好");

方式二：Mixins 模拟

// 父类一
class Person1 {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  eat(food: string): void {
    console.log(this.name + "吃" + food);
  }
}

// 父类二
class Person2 {
  age: number;
  constructor(age: number) {
    this.age = age;
  }

  play(ball: string): void {
    console.log(this.age + "岁玩" + ball);
  }
}

// 创建子类，把父类当成接口，内部的字段和方法必须和父类的字段和方法对应上，用于占位
// 用implements连接多个父类
class Student implements Person1, Person2 {
  grade: string;
  name: string;
  age: number;

  constructor(name: string, age: number, grade: string) {
    this.age = age;
    this.name = name;
    this.grade = grade;
  }

  play(ball: string): void {}
  eat(food: string): void {}
}

// 定义方法 applyMixins，使用js原型链操作连接子类的方法和父类的方法
function applyMixins(derivedCtor: any, baseCtors: any[]) {
  baseCtors.forEach((baseCtor) => {
    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
      derivedCtor.prototype[name] = baseCtor.prototype[name];
    });
  });
}

// 把mixins混入定义的类
applyMixins(Student, [Person1, Person2]);

const alias = new Student("alias", 18, "一年级");
console.log(alias);
alias.eat("面包");
alias.play("棒球");

3. 类实现接口

• 在实现接口的类中，必须按照接口规范来定义类的成员变量和方法（重写接口中的所有变量和方法），只可多不可少
• 接口中定义的所有成员变量和方法都是抽象的，在实现它的类中必须都重写
• 在接口的成员变量后加 ? 代表此成员变量可不用被类重写
• 在接口中的成员方法不写方法体

// 定义接口规范
interface Person {
  name: string;
  age?: number; // 在接口的成员变量后加 ? 代表此成员变量可不用被类实现
  eat(food: string): void; // 在接口中可不写方法体
}

// 定义类实现接口（）
class Student implements Person {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  // 在类中必写方法体
  eat(food: string): void {
    console.log(this.name + "吃" + food);
  }
}

let alias = new Student("alias");
console.log(alias);
alias.eat("苹果");

4. 抽象类

• 抽象类不可以被实例化，只能被继承
• 抽象类中定义的抽象方法必须被继承它的子类重写
• 抽象类中的方法和变量可以是抽象的（被 abstract 修饰）也可以是不抽象的，但接口的方法和变量都是抽象的（都要被重写）
• 在抽象类中的抽象方法不写方法体
• 一个类只能继承一个抽象类

//  定义抽象类
abstract class Person {
  name: string;
  age?: number;
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  // 非抽象方法
  eat(food: string): void {
    console.log(this.name + "吃" + food);
  }

  // 抽象方法，无方法体
  abstract play(ball: string): void;
}

// 定义子类继承抽象类
class Student extends Person {
  sex: string;
  constructor(name: string, age: number, sex: string) {
    super(name, age);
    this.name = name;
    this.sex = sex;
  }

  // 在子类中必须重写抽象类的抽象方法
  play(ball: string): void {
    console.log(this.name + "玩" + ball);
  }
}

let alias = new Student("alias", 18, "女");
console.log(alias);
alias.eat("苹果");
alias.play("篮球");