类
类的概念
类的定义
类的继承
存取器
静态属性和方法
访问修饰符
只读属性
多态
抽象类
- 一个类也可以实现多个接口
接口继承类

类

传统方法中，JavaScript通过构造函数实现类的概念，通过原型链实现继承，TypeScript除了实现了所有 ES6 中的类的功能以外，还添加了一些新的用法

类的概念

类：定义了一件事物的抽象特点，包含它的属性和方法
对象（Object）：类的实例，通过 new 生成
面向对象的三大特性：封装、继承、多态
- 封装：将对数据的操作细节隐藏起来，只暴露对外的接口。外界调用端不需要也不可能知道细节，就能通过对外提供的接口来访问该对象，同时也保证了外界无法任意更改对象内部的数据
- 继承：子类继承父类，子类除了拥有父类的所有特性外，还有一些更具体的特性
- 多态：由继承而产生了相关的不同的类，对同一个方法可以有不同的响应。比如 Cat 和 Dog 都继承自 Animal，但是分别实现了自己的 eat 方法。此时针对某一个实例，无需了解它是 Cat 还是 Dog，就可以直接调用 eat 方法，程序会自动判断出来应该如何执行 eat
存取器（getter & setter）：用以改变属性的读取和赋值行为
修饰符：修饰符是一些关键字，用于限定成员或类型的性质。比如 public 表示公有属性或方法
抽象类：抽象类是供其他类继承的基类，抽象类不允许被实例化。抽象类中的抽象方法必须在子类中被实现
接口（Interfaces）：不同类之间公有的属性或方法，可以抽象成一个接口。接口可以被类实现，一个类只能继承自另一个类，但是可以实现多个接口

类的定义

使用 class 定义类，使用 constructor 定义构造函数。
通过 new 生成新实例的时候，会自动调用构造函数。

class Animal {
  name: string;
  constructor(name) {
    this.name = name;
  }
  sayHi() {
    return `我叫${this.name}`;
  }
}
let du = new Animal("嘟嘟");
console.log(du.sayHi());

类的继承

使用 extends 关键字实现继承，子类中使用 super 关键字来调用父类的构造函数和方法。

class Dog extends Animal {
  color: string;
  constructor(name, color) {
    super(name);
    this.color = color;
  }
  sayHi() {
    return super.sayHi() + "我是一只" + this.color + "色的狗";
  }
}
let a = new Dog("啊啊", "黑色");
console.log(a.sayHi());
let b = new Dog("哈哈", "白色");
console.log(b.sayHi());

存取器

使用 getter 和 setter 可以改变属性的赋值和读取行为

静态属性和方法

使用 static 定义一个静态属性或方法。静态方法不需要实例化，而是直接通过类来调用

访问修饰符

public

公有属性或方法，可以在任何地方被访问到，默认所有的属性和方法都是 public的

class Animal {
  public name;
  public constructor(name) {
    this.name = name;
  }
}
let a = new Animal("Jack");
console.log(a.name); // Jack
a.name = "Tom";
console.log(a.name); // Tom

name 被设置为了 public，所以直接访问实例的 name 属性是允许的

private

私有属性或方法，不能在声明它的类的外部访问，也不可以在子类中访问

很多时候，我们希望有的属性是无法直接存取的，这时候就可以用 private 了

class Animal {
  private name;
  public constructor(name) {
    this.name = name;
  }
}
let a = new Animal('Jack');
console.log(a.name); // Jack
a.name = 'Tom'; // Error  属性'name'为私有属性，只能在类'Animal'中访问

当构造函数修饰为 private 时，该类不允许被继承或者实例化

class Animal {
  public name;
  private constructor(name) {
    this.name = name;
  }
}
class Cat extends Animal {
  constructor(name) {
    super(name);
  }
}
let a = new Animal("Jack"); // Error

protected

受保护的属性或方法，它和 private 类似，区别是它可以在子类中访问

class Animal {
  protected name;
  public constructor(name) {
    this.name = name;
  }
}
class Cat extends Animal {
  constructor(name) {
    super(name);
    console.log(this.name);
  }
}

只读属性

只读属性关键字，只允许出现在属性声明或索引签名或构造函数中。

多态

同一个父类的多个子类，可以有不同结果的同名方法

class Person {
  eat() {
    console.log("eat");
  }
}
class A extends Person {
  eat() {
    console.log("A eat");
  }
}
class B extends Person {
  eat() {
    console.log("B eat");
  }
}

抽象类

abstract 用于定义抽象类和其中的抽象方法

抽象类是提供给其他类继承的基类（父类），是不允许被实例化
抽象方法只能包含在抽象类中
子类继承抽象类，必须实现抽象类中的抽象方法 ```typescript abstract class Person { abstract eat(); // 抽象方法 sleep() { console.log(“sleep”); } }

let a = new Person(); // Error 抽象类是无法被实例化的

class hans extends Person { // 父类定义的eat抽象方法必须被实现 eat() { console.log(“eat”); } }


<a name="g6jFR"></a>
# 类与接口 
<a name="VQAcR"></a>
### implements
`implements`是面向对象中的一个重要概念，一般来讲，一个类只能继承自另一个类，有时候不同类之间可以有一些共有的特性，这时候就可以把特性提取成接口，用 `implements `关键字来实现，大大提高了灵活性
```typescript
interface Ieat {
   eat();
}
class Person implements Ieat{
  eat(){}
}
class Animal implements Ieat {
  eat(){}
}

一个类也可以实现多个接口

interface Ieat {
   eat();
}
interface Isleep {
    sleep();
}
class Person implements Ieat, Isleep{
  eat(){}
  sleep() {}
}

接口继承类

class num1 {
  x: number;
  y: number;
}
interface num2 extends num1 {
  z: number;
}
let num3: num2 = { x: 1, y: 2, z: 3 };

Class 类

类