概念

直接看代码去理解，它是个类，即模版。
实例化一个类，我们就可以去指挥这个类的方法。

  1. class People {
  2.   public name: string;
  3.   public age: number;
  4.   constructor(name: string, age: number) {
  5.     this.name = name
  6.     this.age = age
  7.   }
  8.   eat() {
  9.     alert(`${this.name} eat something`)
  10.   }
  11.   speak() {
  12.     alert(`My name is ${this.name},age ${this.age}`)
  13.   }
  14. }
  15. let kipsong = new People('kipsong', 23)
  16. kipsong.eat()
  17. kipsong.speak()

三要素

继承：子类继承父类

比如创建一个子类Student类，来继承父类People类
那么子类Student可拥有父类People的的属性和方法。

  1. class Student extends People {
  2.   public number: string;
  3.   constructor(name: string, age: number, number: string) {
  4.     super(name, age)
  5.     this.number = number
  6.   }
  7.   study() {
  8.     alert(`${this.name} study`)
  9.   }
  10. }
  12. let kipsong = new Student('kipsong', 23, "001")
  13. kipsong.study()    // 子类定义的
  14. kipsong.eat()        // 父类定义的
  15. kipsong.speak() // 父类定义的

总结：继承可将公共方法抽离出来，提高复用，减少冗余

封装：数据的权限可保密

关键字：
public 公开
protected 只可在父类和子类的类中访问，实例对象不可访问
private 只有在父类的类中访问
默认 公开（和java不一样）

protected只能在类中可访问，实例对象不可访问

  1. class People {
  2.   protected name: string;
  3.   public age: number;
  4.   constructor(name: string, age: number) {
  5.     this.name = name
  6.     this.age = age
  7.   }
  8.   eat() {
  9.     alert(`${this.name} eat something`)
  10.   }
  11.   speak() {
  12.     alert(`My name is ${this.name},age ${this.age}`)
  13.   }
  14. }
  16. let kip = new People("kip",23)
  17. kip.name  // 报错
  19. class Student extends People {
  20.   public number: string;
  21.   constructor(name: string, age: number, number: string) {
  22.     super(name, age)
  23.     this.number = number
  24.   }
  25.   study() {
  26.     alert(`${this.name} study`)
  27.   }
  28. }
  30. let kipsong = new Student('kipsong', 23, "001")
  31. kipsong.name  // 报错

private 只有在父类的类中访问

  1. class People {
  2.   public name: string;
  3.   private age: number;
  4.   constructor(name: string, age: number) {
  5.     this.name = name
  6.     this.age = age
  7.   }
  8.   eat() {
  9.     alert(`${this.name} eat something`)
  10.   }
  11.   speak() {
  12.     alert(`My name is ${this.name},age ${this.age}`)
  13.   }
  14. }
  16. var kip = new People('kip',23)
  17. kip.age // 报错Property 'age' is private and only accessible within class 'People'.

总结：减少耦合，不该外露的不外露 利于数据、接口的权限管理
**

多态：同一个接口不同实现

重写：子类可重写父类的方法

  2. class People {
  3.   public name: string;
  4.   constructor(name: string) {
  5.     this.name = name
  6.   }
  7.   doSomething() {
  8.     alert('People do something')
  9.   }
  10. }
  12. class A extends People {
  13.   constructor(name: string) {
  14.     super(name)
  15.   }
  16.   doSomething() {
  17.     alert('A do something')
  18.   }
  19. }
  21. let a = new A('kip')
  22. a.doSomething()    // A do something

注意：这里没有Java中的重载概念，如果子类中含有父类的方法，可以都理解为重写父类方法。