• 类与接口
    • 类实现接口
    • 接口继承接口
    • 接口继承类
    • 混合类型
    • 参考

    类与接口

    之前学习过，接口（Interfaces）可以用于对「对象的形状（Shape）」进行描述。

    这一章主要介绍接口的另一个用途，对类的一部分行为进行抽象。

    类实现接口

    实现（implements）是面向对象中的一个重要概念。一般来讲，一个类只能继承自另一个类，有时候不同类之间可以有一些共有的特性，这时候就可以把特性提取成接口（interfaces），用 implements 关键字来实现。这个特性大大提高了面向对象的灵活性。

    举例来说，门是一个类，防盗门是门的子类。如果防盗门有一个报警器的功能，我们可以简单的给防盗门添加一个报警方法。这时候如果有另一个类，车，也有报警器的功能，就可以考虑把报警器提取出来，作为一个接口，防盗门和车都去实现它：

    1. interface Alarm {
    2.     alert();
    3. }
    5. class Door {
    6. }
    8. class SecurityDoor extends Door implements Alarm {
    9.     alert() {
    10.         console.log('SecurityDoor alert');
    11.     }
    12. }
    14. class Car implements Alarm {
    15.     alert() {
    16.         console.log('Car alert');
    17.     }
    18. }

    一个类可以实现多个接口：

    1. interface Alarm {
    2.     alert();
    3. }
    5. interface Light {
    6.     lightOn();
    7.     lightOff();
    8. }
    10. class Car implements Alarm, Light {
    11.     alert() {
    12.         console.log('Car alert');
    13.     }
    14.     lightOn() {
    15.         console.log('Car light on');
    16.     }
    17.     lightOff() {
    18.         console.log('Car light off');
    19.     }
    20. }

    上例中，Car 实现了 Alarm 和 Light 接口，既能报警，也能开关车灯。

    接口继承接口

    接口与接口之间可以是继承关系：

    1. interface Alarm {
    2.     alert();
    3. }
    5. interface LightableAlarm extends Alarm {
    6.     lightOn();
    7.     lightOff();
    8. }

    上例中，我们使用 extends 使 LightableAlarm 继承 Alarm。

    接口继承类

    接口也可以继承类：

    1. class Point {
    2.     x: number;
    3.     y: number;
    4. }
    6. interface Point3d extends Point {
    7.     z: number;
    8. }
    10. let point3d: Point3d = {x: 1, y: 2, z: 3};

    混合类型

    之前学习过，可以使用接口的方式来定义一个函数需要符合的形状：

    1. interface SearchFunc {
    2.     (source: string, subString: string): boolean;
    3. }
    5. let mySearch: SearchFunc;
    6. mySearch = function(source: string, subString: string) {
    7.     return source.search(subString) !== -1;
    8. }

    有时候，一个函数还可以有自己的属性和方法：

    1. interface Counter {
    2.     (start: number): string;
    3.     interval: number;
    4.     reset(): void;
    5. }
    7. function getCounter(): Counter {
    8.     let counter = <Counter>function (start: number) { };
    9.     counter.interval = 123;
    10.     counter.reset = function () { };
    11.     return counter;
    12. }
    14. let c = getCounter();
    15. c(10);
    16. c.reset();
    17. c.interval = 5.0;

    参考

    • Interfaces（中文版）