typescript基础篇（5）：类
5.类
5.1 类的声明与继承
ts的类基本包括了es6+中类的全部功能。假如我要声明一条“狗”类，在ts中实现一个类是这样的：
class Dog {
constructor(name: string) {
this.name = name
}
name: string
run() {
console.log(`${this.name} is running`)
}
}
const dog = new Dog("Bobby")类属性都是实例属性，而不是原型属性。ts中属性必须被初始化。
如果为狗类声明一个子类（哈士奇类）,并且有哈士奇有它的属性：颜色：
class Hasky extends Dog {
constructor(name: string, color: string) {
super(name)
this.color = color
}
color: string
}
const hasky = new Hasky("haha", "white")
hasky.run() // haha is running
console.log(hasky.color) // white5.2 修饰符
5.2.1 public
类所有默认的修饰符都是public。表示作用域内所有成员可见。如：
class Dog {
constructor(name: string) {
this.name = name
}
public name: string // 类型注解
run() {
console.log(`${this.name} is running`)
}
}可以不写。在构造函数的参数上使用public等同于创建了同名的成员变量。
5.2.2 private
表示为一个类的私有成员，只有类本身内部可以调用，子类和实例无法调用：
class Dog {
constructor(name: string) {
this.name = name
}
public name: string // 类型注解
// 私有成员
private eat() {
console.log(`dog is eating`)
}
run() {
console.log(`${this.name} is running`)
}
}如果private修饰constructor，表示这个类既不能被实例化，也不能被继承。
5.2.3 protected
Protected修饰需要保护的成员——只能在类和子类中访问，但不能在它们的实例中访问
如果protected修饰的contructor，那么表示它不能被实例化，而只能被继承。也就是所谓的“基类”。
5.2.4 readonly
只读属性。不可以被修改，必须在属性中被实例化。
5.2.5 修饰参数
修饰符也可以用于修饰参数。比如我在参数重直接public color，就不必再申明了，构造函数的写法都可以不写了。
class Hasky extends Dog {
constructor(name: string, public color: string) {
super(name)
}
}5.2.6 static
静态成员只能通过类名来调用，可以被继承。
class Dog {
constructor(name: string) {
this.name = name
}
public name: string // 类型注解
private eat() {
console.log(`dog is eating`)
}
protected sleep() {}
static food: string = "aaa"
run() {
console.log(`${this.name} is running`)
}
}5.3 抽象类与多态
ts的抽象类是对js的又一扩展。如果做这么一个类比：有一个“动物”类，它抽象概括了大部分生物的特征，但它没法被实例化，只有通过”狗“类，“人”类等子类来使之形象化。
因而，可以说抽象类是只能被继承但不能实例化的类。在ts中，通过abstract来声明抽象类。
abstract class Animal {
constructor() {}
shout() {
console.log("shout")
}
}
class Dog extends Animal {
constructor(public name: string) {
super()
}
run() {
console.log(`${this.name} is running`)
}
}
const dog = new Dog("Bobby")
dog.shout()抽象类中，也可以不指定方法等具体实现，这就构成了抽象方法。子类有此实现，就没必要在在父类中实现了。
abstract class Animal {
constructor() {}
abstract shout(): void
}
class Cat extends Animal {
constructor() {
super()
}
shout() {
console.log("miao")
}
}
class Dog extends Animal {
constructor() {
super()
}
shout() {
console.log("wang")
}
}
const animals: Animal[] = [new Cat(), new Dog()]
animals.forEach((animal) => {
animal.shout()
})// miao wang上面的例子中，给Animal定义了一个shout方法。但是具体的实现交给了子类来完成。从这个意义来说，模板方法模式的思想很好地得到了实现。
不单类可以多态，this也可以多态。我想在ts中实现类似jquery的链式调用。和js写法一致，思路依然是在原型方法中return this。
class WorkFlow {
step1() {
return this
}
step2() {
return this
}
}
new WorkFlow().step1().step2()如果在子类中这么做，this可以同时调用子类和父类的方法：
class MyFlow extends WorkFlow {
next() {
return this
}
}
new MyFlow().step1().next().step2()5.4 类与接口的关系
实现（implements）是面向对象中的一个重要概念。一般来讲，一个类只能继承自另一个类，有时候不同类之间可以有一些共有的特性，这时候就可以把特性提取成接口（interfaces），用 implements 关键字来实现。这个特性大大提高了面向对象的灵活性。
举例来说，门是一个类，防盗门是门的子类。如果防盗门有一个报警器的功能，我们可以简单的给防盗门添加一个报警方法。这时候如果有另一个类，车，也有报警器的功能，就可以考虑把报警器提取出来，作为一个接口，防盗门和车都去实现它。
通过接口，可以约束类成员有哪些属性，还有哪些类型。比如说，我先定义一个“人”类，包括name属性（string），和eat方法（void）。然后通过implements关键字，按照这个接口去实现“亚洲人”类。
interface Human {
name: string
eat(): void
}
class Asian implements Human {
constructor(public name: string) {}
eat() {}
}注意，类必须要完整声明完接口声明的成员（公有成员，不可改动）。如果类有自己的属性，这是可以的。也不能在接口定义构造函数。
5.4.1 接口之间的继承
interface Human {
name: string
eat(): void
}
class Asian implements Human {
constructor(public name: string) {}
eat() {}
}
interface American extends Human {
run(): void
}
interface European extends Human {
cry(): void
}
interface African extends American, European {}
// 必须完整定义完父接口的方法
const p: African = {
name: "",
run() {},
cry() {},
eat() {},
}这里p实际上也是被编译为一个对象。
5.4.2 接口与类之间的继承
接口继承类，然后再用一个类来继承这个接口：
class Auto {
state = 1
}
interface AutoInterface extends Auto {}
class C implements AutoInterface {
state = 1
}在此，如果C不定义state，将会报错。
下图反映了接口和类的关系：
腾讯云开发者
