TypeScript常用知识（类）

TypeScript常用知识（类）

如何理解类？

类：可以理解为模版，通过模版可以实例化对象（面向对象的编程思想）
面向对象的特点：封装、继承、多态
一般写法（封装）：

class Animal{
  // 定义属性
  name="";
  // 定义方法
  sayHi(){
    alert('hello!')
  };
  // 构造方法,实例化类的时候,自动调用
  constructor(name){
	this.name = name
  }
}
let dog = new Animal()
一般要通过new关键字实例化对象进行调研

继承

用来描述类与类之间的关系

class B {
  run(distance: number) {
    console.log(`Animal run ${distance}m`)
  }
}

class A extends B {
  cry() {
    console.log('wang! wang!')
  }
}

const dog = new A()
dog.cry()
dog.run(100) // 可以调用从父中继承得到的方法

这个例子展示了最基本的继承：子类从基类中继承了属性和方法。 在这里A 是一个 派生类，它通过 extends 关键字派生于 B基类。 一般派生类被称为子类，基类被称为超类。
一旦发生了继承关系，就出现了父子类的关系。

多态

父类型的引用指向了子类型的对象，不同类型的对象针对相同的方法产生了不同的行为。

class Animal {
  name: string

  constructor(name: string) {
    this.name = name
  }

  run(distance: number = 0) {
    console.log(`${this.name} run ${distance}m`)
  }
}

class Snake extends Animal {
  constructor(name: string) {
    // 调用父类型构造方法
    super(name)
  }

  // 重写父类型的方法
  run(distance: number = 5) {
    console.log('sliding...')
    super.run(distance)
  }
}

class Horse extends Animal {
  constructor(name: string) {
    // 调用父类型构造方法
    super(name)
  }

  // 重写父类型的方法
  run(distance: number = 50) {
    console.log('dashing...')
    // 调用父类型的一般方法
    super.run(distance)
  }

  xxx() {
    console.log('xxx()')
  }
}

const snake = new Snake('sn')
snake.run()

const horse = new Horse('ho')
horse.run()

// 父类型引用指向子类型的实例 ==> 多态
const tom: Animal = new Horse('ho22')
tom.run()

/* 如果子类型没有扩展的方法, 可以让子类型引用指向父类型的实例 */
const tom3: Snake = new Animal('tom3')
tom3.run()
/* 如果子类型有扩展的方法, 不能让子类型引用指向父类型的实例 */
// const tom2: Horse = new Animal('tom2')
// tom2.run()

类与类之间如果要有继承关系，则需使用extends关键字；
子类中可以调用父类中的构造函数（包括调用父类中的实例方法），使用super关键字，同时子类中可以重写父类的方法

修饰符

主要用来描述类中的成员（属性、构造函数、方法）的可访问性。
public：公共的，任何位置都可以访问类中的成员（成员中默认的访问修饰符）；
private：私有的，外部无法访问该成员数据，同时子类也无法访问；
protected：受保护的，外部无法访问该成员数据，但子类中可以访问该成员的数据。
readonly：只读的，对类中的属性成员进行修饰，表明该成员是只读的，不能在外部被随意修改，但在构造函数中可以对只读的属性成员的数据进行修改。

class Animal {
  public name: string

  public constructor(name: string) {
    this.name = name
  }

  public run(distance: number = 0) {
    console.log(`${this.name} run ${distance}m`)
  }
}

class Person extends Animal {
  private age: number = 18
  protected sex: string = '男'

  run(distance: number = 5) {
    console.log('Person jumping...')
    super.run(distance)
  }
}

class Person {
  readonly name: string = 'abc'
  constructor(name: string) {
    this.name = name
  }
}

let john = new Person('John')

如果构造函数中没有任何参数，类中的属性成员用readonly修饰，则外部也不可更改属性值；
如果构造函数中的参数用readonly进行修饰，则表示该类中有只读的成员属性；
如果构造函数中的参数用public、private、protected进行修饰，无论是哪个进行修饰，则该类中自动添加对应性质的属性成员。

存取器

存取器可以让我们有效的控制对对象中的成员的访问，一般是通过getters和setters来操作的。

class Person {
  firstName: string = 'A'
  lastName: string = 'B'
  // get:读取器，负责读取数据
  get fullName() {
    return this.firstName + '-' + this.lastName
  }
  //set：设置器，负责设置数据的修改
  set fullName(value) {
    const names = value.split('-')
    this.firstName = names[0]
    this.lastName = names[1]
  }
}

静态成员

在类中通过static修饰的属性或方法，称之为静态成员
静态成员在使用的时候是通过类名.的语法来调用的。

class Person {
  name1: string = 'A'
  static name2: string = 'B'
}

console.log(Person.name2)

抽象类

抽象类做为其它派生类的基类使用。 它们不能被实例化。不同于接口，抽象类可以包含成员的实现细节。 abstract 关键字是用于定义抽象类和在抽象类内部定义抽象方法。
抽象类的目的及作用最终都是为子类服务的。

抽象类是不能被实例化的，为了让子类进行实例化及实现内部的抽象方法
abstract class Animal {
  abstract cry()

  run() {
    console.log('run()')
  }
}

class Dog extends Animal {
  cry() {
    console.log(' Dog cry()')
  }
}