TypeScript系列(四)类的初体验

类的介绍

ES6以前Javascript是使用函数和基于原型的继承来实现类的概念。而在Typescript中则能够和ES6及更新的版本中同样使用class 关键字，面向对象的方式使用类。这篇文章，就让咱们一块儿好好了解一下类。

类的定义

类能够有本身的构造函数，属性，以及方法。使用new 构造一个对象的实例。这个过程当中会调用类的构造函数，建立一个新对象，并在执行完构造函数后返回这个新对象；

class Animal {
    // 构造函数默认返回Animal对象
    constructor (msg: string) {
        this.name = msg;
    }
    name: string；
    run() {
        console.log('run');
    }
}

let animal = new Animal('test');

这里值得一提的是，虽然咱们用的是class关键字来使用类，可是咱们仍是要明白，这只是高级语法糖而已，其实最终仍是基于原型的。类的成员属性都是实例属性，不是在原型上，类的成员方法都是在原型上。以上面的例子说明，name 属性就存在与实例 animal，而方法run则是在原型Animal.prototype上。

类的成员修饰符

类的成员修饰符能够有如下几种，public， private， protected以及readonly。

public
在typescript中，成员默认都是public，也能够明确的写出来。咱们能够自由的访问程序里定义为的public成员，包括实例和子类。

private
private的成员不能在类的外部访问。实例和子类中都不行。当在构造函数constructor上加上private修饰符的话，那么这个类既不能被实例化，也不能被继承。

protected
和私有化成员相似，可是受保护的成员能够在子类中访问。当constructor被声明为protected的时候，这个类就不能被实例化，只能被继承，至关于一个基类使用。

readonly
readonly关键字将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化。

static
使用static修饰符的成员为静态成员，只能经过类名来访问，举个例子：

class People {
    constructor() {
    }
    static name = 'Kobe';
}
let p = new People();

console.log(p.name) // 会报错，不能经过实例访问
console.log(People.name); // Kobe

参数属性
在构造函数的参数前使用修饰符声明，那么参数属性直接声明一个属性成员，举个例子：

class Foo {
    constructor(public name: string){
    }
}

let f = new Foo('Mike');
// 能够直接访问name属性
console.log(f.name); // Mike

存取器

TypeScript经过getters/setters来截取对对象成员的访问。 能有效的控制对对象成员的访问。只带有get不带有set存取器的属性会被自动推断为readonly。

class Student{
    private _name: string;
    get name() {
        return this._name
    }
    set name(value) {
        this._name = value;
        console.log('setter: ' + value);
    }
}

let s = new Student();
s.name = 'Tom'; // setter: Tom
console.log(a.name); // Tom

抽象类

抽象类就是只能被继承，不能实例化的类。使用abstract关键字来定义抽象类和抽象方法。用来抽离事物的共性，实现代码复用和扩展。其中抽象类的方法能够有具体实现，也能够没有，没有的话就必须在子类中实现，比较灵活。而后就是在派生类的构造函数中必须调用 super()。看下面的例子：

abstract class People{
    abstract task(): void; // 必须被实现
    sayHi(): void {
        console.log('Hi');
    }
}

class Student extends People {
    constructor() {
        super();
    }
    
    task(): void {
        console.log('learing');
    }
}

类和接口的关系

接口之间能够相互继承，类之间也能够相互继承。类能够实现接口，接口能够继承类。主要举两个例子说明一下。

接口继承接口

interface People {
    name: string;
}

// 接口继承单个接口
interface Boy extends People {
    classNumber: number;
}

// 接口继承多个个接口， 以 , 分隔
interface Student extends People, Boy {

}
// 对象具备两个`interface`的属性
let stu: Student = {
    name: 'Mike',
    classNumber: 5
}

接口继承类
这种用法不是不少，至关于接口把类的成员抽象出来，只有成员结构，没有具体实现。

class Component {
    name: string;
    dispaly(): void {
        console.log('displaying');
    }
}

interface Widget extends Component {
    hide(): void;
}

// 类实现接口，必须实现两个方法
class Button implements Widget {
    // name属性也是必须的
    name: string;
    dispaly(): void {
        console.log('displaying in Button');
    }
    hide(): void {
        console.log('hiding');
    }
}