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');
	}
}