Typescript基础3--类

类

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)

Paste_Image.png

其类型也是函数。

class Dabao {
        constructor(){}
}
console.log(Dabao === Dabao.prototype.constructor)

Paste_Image.png

上面代码表明，类的数据类型就是函数，类本身就指向构造函数

class Dabao {
        constructor(){}
        setName(){ }
        setAge(){}
}
console.log(Dabao.prototype)

Paste_Image.png

function Dabao(){
}
Dabao.prototype.setName = function(){}
Dabao.prototype.setAge = function(){}
console.log(Dabao.prototype)

Paste_Image.png

上面两种方法是相同的

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)

Paste_Image.png

在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()只能用在子类的构造函数之中，用在其他地方就会报错。

Paste_Image.png

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 内部使用
    }
}

Paste_Image.png

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
    }
}

Paste_Image.png

存取器

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)

Paste_Image.png

抽象类

抽象类做为其它派生类的基类使用。 它们一般不会直接被实例化。 不同于接口，抽象类可以包含成员的实现细节。 abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法。
抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。

Paste_Image.png Paste_Image.png

必须在派生类中实现

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;