类

文档
类就是用来创造对象的东西。
有一些语言（如 Java，存疑）创建对象必须先声明一个类，而有的语言（JS）则不需要。

对于使用过 TS 的 JS 程序员来说，类可以让你的系统更加「可预测」

这个对象不会出现一些我不知道的属性，一切都尽在我的掌握。
代码如下：

class Animal {
    kind: string;
    protected birth: string;
    // 非完全公开，能在自己class内使用和在后代使用
    constructor(kind: string){
        this.kind = kind;
        if (this.kind === '哺乳动物') {
            this.birth = '胎生';
        }else {
            this.birth = '卵生';
        }
    }
    move(): void {}
}

class Human extends Animal{
    static xxx = 1 // 不能在外面使用Human.xxx =1
    //上面为静态属性，不是对象的属性，是Human的属性
    name: string;
    private _age: number;
    private secret: string;
    //私有属性，只能在class内被访问，其他默认为public
    get age() {
        return this._age
    }
    set age(value: number) {
        if(value < 0) {
            this._age = 0;
        }else {
            this._age = value;
        }
    }
    // get set设计模式，先把属性设为私有，如果用户访问则返回并且进行设置
    constructor(name = 'fan', age = 18) { // 不传为默认，传了可以改变
        super('哺乳动物');
 //对比interface 在类继承时，必须调用super，相当于调用了上个类的constructor
        this.name = name;
        this.age = age;
        this.secret = '这是我的secret'
    }
    move(): void {}
    say(): string {
        this.move(); // 可以自己调用自己，通过this沟通
        return 'hi'
    }
}
let fan = new Human();
console.log(fan)
let jack = new Human('jack',19) 
console.log(jack)
console.log(jack.constructor) 
jack.age = -1;
console.log(jack.age);
// 在JS中，constructor也是实例的属性，拥有class的所有属性和方法
// 在使用new的时候，会自动调用constructor
//在调用时，传入参数，并传给this，当执行完，对象的地址将会返还给实例，this消失

打印出的结果

Human {kind: "哺乳动物", birth: "胎生", name: "fan", _age: 18, secret: "这是我的secret"}
1.ts:47
Human {kind: "哺乳动物", birth: "胎生", name: "jack", _age: 19, secret: "这是我的secret"}
1.ts:49
function Human(name, age) { … }
1.ts:50
0
1.ts:52

语法

1. 声明类
2. 声明对象的非函数属性
3. 声明对象的函数属性
4. 使用 constructor
5. 声明类的属性（static）
6. 使用 this 代指当前对象（注意不要以为 this 永远都代指当前对象，JS 的 this 有更多功能，而且默认 this 为 window）

类继承类

1. 使用 super

修饰符

public private 和 protected

访问器

get 和 set

抽象类

也可以叫做「爸爸类」：专门当别的类的爸爸的类。
也可以叫做「没有写完的类」：只描述有什么方法，并没有完全实现这些方法。

由于这个类没有写完，所以不能创建出对象。（会报错）

abstract class Animal {
    abstract makeSound(): void;
    move(): void {
        console.log('roaming the earch...');
    }
}

abstract 就是抽象的意思。我建议你不用管抽象是什么意思，就死记硬背：抽象类就是爸爸类。
抽象类不能创建实例（因为没有写完）

高级技巧

构造函数（如果听不懂这一节，可以以后回头再听）

我有一篇文章可能给你启发：https://zhuanlan.zhihu.com/p/23987456

由于 TS 的 class 其实就是 JS 里的 class，JS 里的 class 其实就是一个构造函数。
换句话说，类就是一个函数……
同时，函数在JS里，是一种对象。
所以类其实是一种对象。
我知道这听起来很奇怪，但是 JS 就是这么奇怪。

class Greeter {
    static standardGreeting = "Hello, there";
    greeting: string;
    greet() {
        if (this.greeting) {
            return "Hello, " + this.greeting;
        }
        else {
            return Greeter.standardGreeting;
        }
    }
}

let greeter1: Greeter;
greeter1 = new Greeter();
console.log(greeter1.greet());

let greeterMaker: typeof Greeter = Greeter;  // 注意这句话
greeterMaker.standardGreeting = "Hey there!";

let greeter2: Greeter = new greeterMaker();
console.log(greeter2.greet());

把类当做接口使用

接口是低配版的类。
类是高配版的接口。

class Point {
    x: number;
    y: number;
}

interface Point3d extends Point {
    z: number;
}

let point3d: Point3d = {x: 1, y: 2, z: 3};