TypeScript学习笔记 -类

前言

出于学习提升、成果展示、记录心得等目的，我选择将自己的一点学习笔记放置出来，希望能够帮助到有需要的人，同时，由于个人知识的片面，文章中可能会出现不正确的地方，希望发现者可以及时指出，以便及时修正，不误导后来人。接下来就开始文章正文吧。

类

归功于版本的更新，JavaScript程序员自ES6开始便可以使用基于类的面向对象的编程思路了，接下来展示一个简单的TypeScript类的实例：

class greet {
    username:string;
    constructor(username){
        this.username=username;
    }
    greet(){
        console.log("Welcome! "+this.username+"!")
    }
}
let greeter=new greet("new user");
greeter.greet();

继承

最为常见的一种基于类的面向对象编程的设计模式，就是通过继承的方式拓展目前现有的类，如下图示例：

class drink {
    name:string;
    constructor(name:string){
        this.name=name;
    }
    observe(){
        console.log('this is '+this.name);
    }
}
class sniff extends drink{
    constructor(name:string){
        super(name);
    }
    sniff(){
        console.log('this sniff like '+this.name);
    }
}
let beer=new sniff("beer");
beer.sniff();
beer.observe();

如图所示，sniff类继承了drink类内部的属性name和方法observe()，并且可以通过super关键字调用基类的构造函数。同时，子类可以对父类的方法进行重写，如下图：

class drink {
    name:string;
    constructor(name:string){
        this.name=name;
    }
    observe(name:string='water'){
        console.log('this is '+name);
    }
    sniff(name:string='water'){
        console.log('this sniff like '+name);
    }
}
class beer extends drink{
    constructor(){
        super("beer");
    }
    sniff(name:string='beer'){
        console.log('this sniff like '+name);
    }
}
let unknown=new beer();
unknown.sniff();
unknown.observe();

这里我们通过子类beer调用父类drink的sniff()和observe()两个函数，上图代码中我们为父类drink中这两个函数设置了默认参数值water，而后在子类beer中重写了sniff()方法，将其默认值修改为beer，而控制台的输出也证明了子类拥有重写父类方法的能力。

公共，私有、受保护以及只读的修饰符

TypeScript中有四种常用的修饰符，分别为公共public，私有private、受保护protected以及只读readonly的修饰符.

public

这是最常见的，也是默认的修饰符类型，如上图中我们曾定义过的

class drink {
    name:string;
}

实际上等同于

class drink {
    public name:string;
}

public修饰符所表示的意思为这个成员是公共的，可以被*地访问。

private

既然有可以被*地访问的修饰符，自然也有不能被*地访问的修饰符，比如private。private指私有类型的成员，即不能在定义所在的类以外被访问，哪怕是子类，同样无法访问父类的私有成员
不过也有例外的情况，比如由同一个类所构造的两个对象，在这两个对象之间私有成员是可以访问和操作的，例如：

class drink {
    private name:string;
    constructor(name:string){
        this.name=name;
    }
    sniff(){
        console.log('this sniff like '+this.name);
    }
}

let beer=new drink('beer');
let water=new  drink("water");
beer.sniff();
beer=water;
beer.sniff();

如图所示，由同一个类构造而来的两个对象之间的私有成员private name:string可以被访问以及修改。

protected

protected的性质与private类似，唯一的不同点在于protected成员在继承的子类中可以被访问，比如上一栏中报错的例子，如果将private修改为protected，则不会报错，可以正常运行。

class drink {
    protected name:string;
    constructor(name:string){
        this.name=name;
    }
}
class beer extends drink{
    constructor(){
        super("beer");
    }
    sniff(){
        console.log('this sniff like '+this.name);
    }
}
let unknown=new beer();
unknown.sniff();

readonly

类中的只读属性很容易理解，就是允许定义，不允许修改，例如：
此处可见，我们可以正常地定义、访问类中的只读成员，但对其进行修改时便会报错。

抽象类

抽象类（关键字为abstract）一般是作为其他派生类的基类出现，且一般不被实例化。在抽象类中可以定义抽象方法，这些抽象方法不包含具体实现并且必须在派生类中实现，举个例子:

abstract class groupmember {
    name:string;
    constructor(name:string){
        this.name=name;
    }
    abstract job():void;
}
class partner extends groupmember{
    constructor(){
        super("partner");
    }
    job(): void {
        console.log("make sure computer is right")
    }

}
let TOM:groupmember;
TOM=new partner();
TOM.job()

此处的groupmember就是抽象类，其定义的抽象方法在其派生类partner才得到了具体的描述和实现。