类
javascript 语言中，生成实例对象的传统方法是通过构造函数。下面是一个例子。
function Dabao(name){
this.name = name
this.age = 10
}
Dabao.prototype.setAge = function(num){
this.age = num
}
var dabao = new Dabao('cxh');
dabao.setAge(24)
从ES6开始引入了 Class（类）这个概念，作为对象的模板。通过class关键字，可以定义类。
用typescript重新定义：
class Dabao {
constructor(name: string){
this.name = name
}
name : string
age : number
setAge(num) {
this.age = num
}
}
let dabao = new Dabao('cxh')
dabao.setAge(24)
console.log(dabao)
其实在原理上是一样的我们打印一下Dabao
class Dabao {
}
console.log(Dabao)
其类型也是函数。
class Dabao {
constructor(){}
}
console.log(Dabao === Dabao.prototype.constructor)
上面代码表明，类的数据类型就是函数，类本身就指向构造函数
class Dabao {
constructor(){}
setName(){ }
setAge(){}
}
console.log(Dabao.prototype)
function Dabao(){
}
Dabao.prototype.setName = function(){}
Dabao.prototype.setAge = function(){}
console.log(Dabao.prototype)
上面两种方法是相同的
constructor方法
constructor方法是类的默认方法，通过new命令生成对象实例时，自动调用该方法。一个类必须有constructor方法，如果没有显式定义，一个空的constructor方法会被默认添加。
class Dabao {}
// 等同于
class Dabao {
constructor() {}
}
类的继承
Class 可以通过extends关键字实现继承，这比 ES5 的通过修改原型链实现继承，要清晰和方便很多。例如
class Dabao {
name : string = 'cxh'
setName(){}
}
class Xiaobao extends Dabao {
constructor(){
super()
}
age : number
setAge (){}
}
let xiaobao = new Xiaobao
console.log(xiaobao.setName)
在xiaobao中可以调用dabao的函数。
我们打印一下各自的prototype看看
class Dabao {
name : string = 'cxh'
setName(){}
}
class Xiaobao extends Dabao {
constructor(){
super()
}
age : number
setAge (){}
}
let xiaobao = new Xiaobao
console.log(Dabao.prototype)
console.log(Xiaobao.prototype)
console.log(dabao)
console.log(xiaobao)
可见xiaobao的proto中是包含了Dabao 的方法和属性。
super 关键字
super这个关键字，既可以当作函数使用，也可以当作对象使用。在这两种情况下，它的用法完全不同。
super作为函数调用时，代表父类的构造函数。
class Dabao {}
class Xiaobao extends Dabao {
constructor(){
super()
}
}
super就是父类的构造函数，但是super内部的this确是指向Xiaobao的。
Dabao.prototype.constructor.call(this)。
作为函数时，super()只能用在子类的构造函数之中，用在其他地方就会报错。
class Dabao {
static setAge(){
console.log(1)
}
}
class Xiaobao extends Dabao {
static setName(){
super.setAge()
}
}
Xiaobao.setName()
公共，私有与受保护的修饰符
public:TypeScript里，成员都默认为 public。这里不在详细介绍。
private：
当成员被标记成private时，它就不能在声明它的类的外部访问。比如：
class Person {
private name : string
constructor(n : string){
this.name = n
}
}
var p = new Person('dabao')
console.log(p.name) //错误 仅能在class 内部使用
class Son extends Person{
constructor(n:string){
super(n)
this.name = n //错误 仅能在class 内部使用
}
}
protected
class Animal {
protected name : string
constructor(n){
this.name = n
}
}
var a = new Animal('cxh')
console.log(a.name) //仅仅能在 类内部引用 以及 她的子类
class Dog extends Animal{
constructor(n){
super(n)
this.name = n
}
}
存取器
TypeScript支持通过getters/setters来截取对对象成员的访问。它能帮助你有效的控制对对象成员的访问。
class Dabao {
private _name : string
get name(): string {
return this._name;
}
set name(newName: string) {
this._name = newName
}
}
var dabao = new Dabao;
dabao.name = 'cxh'
console.log(dabao.name)
抽象类
抽象类做为其它派生类的基类使用。 它们一般不会直接被实例化。 不同于接口，抽象类可以包含成员的实现细节。 abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法。
抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。
必须在派生类中实现
abstract class Dabao {
constructor(public name: string) {
}
abstract setName (name:string) : void
}
class Xiaobao extends Dabao {
name : string
setName (name:string) : void {
this.name = name
}
}
其实抽象方法和接口是相似的。
类的 prototype 属性和proto属性
大多数浏览器的 ES5 实现之中，每一个对象都有proto属性，指向对应的构造函数的prototype属性。Class 作为构造函数的语法糖，同时有prototype属性和proto属性，因此同时存在两条继承链。
（1）子类的proto属性，表示构造函数的继承，总是指向父类。
（2）子类prototype属性的proto属性，表示方法的继承，总是指向父类的prototype属性。
class Dabao {
name : string = 'cxh'
setName(name : string) {
this.name = name
}
}
class Xiaobao extends Dabao {
constructor(){
super()
}
age : number = 123
setAge(age: number) {
this.age = age
}
}
console.log(Dabao)
console.log(Xiaobao)
console.log(Dabao.prototype)
console.log(Dabao.__proto__)
console.log(Xiaobao.__proto__ == Dabao) //子类的__proto__属性，表示构造函数的继承，总是指向父类
Xiaobao.prototype.__proto__ === Dabao.prototype //子类prototype属性的__proto__属性，表示方法的继承，总是指向父类的prototype属性。
所以Xiaobao集成Dabao就是相当于
Xiaobao.prototype.__proto__ = Dabao.prototype;
Xiaobao.__proto__ = Dabao;
