TypeScript 编程语言的界面,是 TypeScript 特有、JavaScript 没有的东西,它与 declare 关键字类似,只是用来写给编译器看的。TypeScript 的界面可以将对象类型抽象化并加上名称,形成新的类型,还能让类别根据界面来添加属性。

还记得在上一章中,我们是怎么撰写对象的类型吗?

用以下这个大括号 {} 对象为例:

const o = {
    name: "David",
    age: 18,
    toString: function () {
        return `${this.age}: ${this.name}`;
    },
};

它的类型就是 { name: string, age: number, toString: () => string }。所以我们可以用以下的方式来明确定义变量 o 的类型:

const o: { name: string, age: number, toString: () => string } = {
    name: "David",
    age: 18,
    toString: function () {
        return `${this.age}: ${this.name}`;
    },
};

我们可以透过 TypeScript 的界面,将 { name: string, age: number, toString: () => string } 这个类型加上名称。例如要将其命名为 User,程序如下:

interface User {
    name: string,
    age: number,
    toString: () => string
}

const o: User = {
    name: "David",
    age: 18,
    toString: function () {
        return `${this.age}: ${this.name}`;
    },
};

如何?有没有觉得程序更容易阅读了?

用类别对象实作界面

我们还可以在撰写类别对象的时候,于类别名称后面使用 implements 关键字来指定要实作的界面。界面拥有的属性,除了可选的属性之外,实作该界面的类别也都要有。

例如:

interface User {
    name: string,
    age: number,
    toString: () => string
}

class Student implements User {
    name: string;

    age: number;

    toString: () => string;

    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
        this.toString = () => `${this.age}: ${this.name}`;
    }
}

我们无法用 instanceof 关键字来判断某个值是否属于指定的界面。例如以下程序会编译错误:

interface User {
    name: string,
    age: number,
    toString: () => string
}

class Student implements User {
    name: string;

    age: number;

    toString: () => string;

    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
        this.toString = () => `${this.age}: ${this.name}`;
    }
}

const o = new Student("David", 18);

console.log(o instanceof User);

implements 关键字和 extends 关键字可以一同使用,但是 implements 关键字必须要放在 extends 关键字之后。

例如:

class User {
    name: string;

    protected type = "user";

    constructor(name: string) {
        this.name = name;
    }

    whoAmI() {
        return `My name is ${this.name}. I am a ${this.type}.`;
    }
}

class Human extends User {
    constructor(name: string) {
        super(name);
        this.type = "human";
    }
}

class Robot extends User {
    constructor(name: string) {
        super(name);
        this.type = "robot";
    }
}

interface Studiable {
    study: () => void
}

class Student extends Human implements Studiable {
    study = () => {
        console.log("I'm studying!");
    };

    constructor(name: string) {
        super(name);
        this.type = "student";
    }
}

extends 关键字只能继承一个类别。implements 关键字则可以用来实作多个界面,用逗号 , 隔开多个界面名称。

例如:

class User {
    name: string;

    protected type = "user";

    constructor(name: string) {
        this.name = name;
    }

    whoAmI() {
        return `My name is ${this.name}. I am a ${this.type}.`;
    }
}

class Human extends User {
    constructor(name: string) {
        super(name);
        this.type = "human";
    }
}

class Robot extends User {
    constructor(name: string) {
        super(name);
        this.type = "robot";
    }
}

interface Studiable {
    study: () => void
}

interface Expellable {
    expel: () => void
}

class Student extends Human implements Studiable, Expellable {
    study = () => {
        console.log("I'm studying!");
    };

    expel = () => {
        console.log("Noooo!");
    };

    constructor(name: string) {
        super(name);
        this.type = "student";
    }
}

扩充界面

借由重复撰写 interface 关键字,可以替已存在的界面扩充原本不存在的属性。

例如:

interface Point {
    x: number,
    y: number
}

interface Point {
    z: number
}

class Vertex implements Point {
    x: number;

    y: number;

    z: number;

    constructor(x: number, y: number, z: number) {
        this.x = x;
        this.y = y;
        this.z = z;
    }
}

以上程序,Point 界面实际为:

interface Point {
    x: number,
    y: number,
    z: number
}

界面继承界面

界面也可以使用 extends 关键字来继承其它界面。这功能其实就是刚才提到的「扩充界面」,只不过多用了 extends 关键字来保留原本的界面名称。

例如:

interface Point2D {
    x: number,
    y: number
}

interface Point3D extends Point2D {
    z: number
}

class Vertex implements Point3D {
    x: number;

    y: number;

    z: number;

    constructor(x: number, y: number, z: number) {
        this.x = x;
        this.y = y;
        this.z = z;
    }
}

与类别不同的是,类别的 extends 关键字后只能接上一个类别名称,而界面的 extends 关键字后可以接上多个界面名称或是类别名称,要用逗号 , 隔开。

例如:

interface PointX {
    x: number
}

interface PointY {
    y: number
}

interface PointZ {
    z: number
}

interface Point2D extends PointX, PointY {

}

interface Point3D extends Point2D, PointZ {

}

class Vertex implements Point3D {
    x: number;

    y: number;

    z: number;

    constructor(x: number, y: number, z: number) {
        this.x = x;
        this.y = y;
        this.z = z;
    }
}

界面和类别的名称重复

在 TypeScript 中,界面和类别的名称是可以重复的。重复名称的界面会扩充类别的属性,但类别可以不必照着这个重复名称的界面来实作程序。

例如:

interface Student {
    dropOut: () => void
}

class Student {
    name: string;

    age: number;

    toString: () => string;

    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
        this.toString = () => `${this.age}: ${this.name}`;
    }
}

const o = new Student("David", 18);

o.dropOut();

以上程序虽然可以成功编译,但会运行失败,因为 Student 对象实体并没有 dropOut 方法。

抽象类别(Abstract Class)

在定义一个类别的时候,可以在其 class 关键字前加上 abstract,使其变成抽象类别。TypeScript 的抽象类别和一般类别的差异不大,只不过就是不能够被「new」而已。

例如:

interface PointX {
    x: number
}

interface PointY {
    y: number
}

interface PointZ {
    z: number
}

interface Point2D extends PointX, PointY {

}

interface Point3D extends Point2D, PointZ {

}

abstract class AbstractVertex implements Point3D {
    x: number;

    y: number;

    z: number;

    constructor(x: number, y: number, z: number) {
        this.x = x;
        this.y = y;
        this.z = z;
    }
}

class Vertex extends AbstractVertex {
    constructor(public x: number, public y: number, public z: number) {
        super(x, y, z);
    }
}

以上的 AbstractVertex 类别是一个抽象类别,它不能够被用 new 关键字来产生对象实体,但是它可以被继承,也可以透过其子类别 Vertex 的构造器来调用到 AbstractVertex 类别的构造器。

我们也可以在抽象类别的属性(字段或是方法都可以)前加上 abstract 关键字来修饰,使得继承这个抽象类别的类别必须要实作这个属性。使用 abstract 关键字来修饰的属性,不需指定值,也不需实作出函数主体,只要把名称和类型定义出来就好了。

例如:

abstract class Animal {
    abstract readonly name: string;

    abstract makeSound(): void;
  
    move(): void {
        console.log("roaming the earth...");
    }
}

class Dog extends Animal {
    readonly name = "Dog";

    makeSound(): void {
        console.log("Woof!");
    }
}

总结

在这个章节中我们学会了 TypeScript 提供的界面与抽象类别的用法,在下一个章节要来学习 TypeScript 提供的枚举用法。

下一章:TypeScript 编程语言的枚举。