TypeScript 继承|极客教程

TypeScript 继承

在面向对象编程中，继承是一种机制，允许一个类（子类）继承另一个类（父类）的属性和方法。这样可以避免重复代码，并实现代码的重用性和扩展性。在 TypeScript 中也支持类的继承，让我们来详细了解 TypeScript 中的继承。

基础概念

在 TypeScript 中，可以使用 extends 关键字来实现类的继承。子类将会继承父类的属性和方法，同时可以添加自己的属性和方法。

下面是一个简单的示例，演示了如何在 TypeScript 中实现类的继承：

class Animal {
    name: string;

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

    move(distance: number = 0) {
        console.log(` ${this.name} moved$ {distance}m.`);
    }
}

class Dog extends Animal {
    bark() {
        console.log(`${this.name} barked.`);
    }
}

let dog = new Dog('Buddy');
dog.bark();
dog.move(10);

上面的代码定义了一个 Animal 类和一个 Dog 类，Dog 类继承自 Animal 类。Dog 类增加了一个 bark 方法，以及继承自 Animal 类的 move 方法。我们创建了一个 Dog 类的实例，调用了 bark 方法和 move 方法。

构造函数

在子类的构造函数中，可以通过 super 关键字调用父类的构造函数，从而完成父类的初始化。

class Person {
    name: string;

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

class Employee extends Person {
    empCode: number;

    constructor(name: string, empCode: number) {
        super(name);
        this.empCode = empCode;
    }
}

let emp = new Employee('John', 123);
console.log(emp.name); // Output: John
console.log(emp.empCode); // Output: 123

在上面的示例中，Employee 类继承自 Person 类。在 Employee 类的构造函数中，通过 super(name) 调用父类 Person 的构造函数，进行父类的初始化。

方法重写

子类可以重写从父类继承来的方法。当我们在子类中定义一个和父类中同名的方法时，就会发生方法重写。

class Circle {
    radius: number;

    constructor(radius: number) {
        this.radius = radius;
    }

    area() {
        return Math.PI * this.radius * this.radius;
    }
}

class Cylinder extends Circle {
    height: number;

    constructor(radius: number, height: number) {
        super(radius);
        this.height = height;
    }

    area() {
        return 2 * Math.PI * this.radius * (this.radius + this.height);
    }
}

let cylinder = new Cylinder(2, 5);
console.log(cylinder.area()); // Output: 62.83185307179586

在上面的示例中，Cylinder 类继承自 Circle 类，重写了 area 方法。当调用 cylinder.area() 方法时，会调用子类 Cylinder 中的 area 方法。

抽象类

在 TypeScript 中，可以使用抽象类来定义一个基类，该类不能被实例化，而只能被其他类继承。抽象类可以包含抽象方法，这些方法在子类中必须被实现。

下面是一个使用抽象类的示例：

abstract class Shape {
    abstract area(): number;
}

class Circle extends Shape {
    radius: number;

    constructor(radius: number) {
        super();
        this.radius = radius;
    }

    area() {
        return Math.PI * this.radius * this.radius;
    }
}

let circle = new Circle(2);
console.log(circle.area()); // Output: 12.566370614359172

在上面的示例中，Shape 类是一个抽象类，其中定义了一个抽象方法 area()。Circle 类继承自 Shape 类，必须实现 area() 方法。在 Circle 类中实现了 area() 方法，计算了圆的面积。

多重继承

在 TypeScript 中，类只支持单一继承，即一个子类只能继承一个父类。但是可以通过接口的多重继承来实现类似多重继承的功能。

下面是一个使用接口实现多重继承的示例：

interface IPerson {
    name: string;
    age: number;
}

interface IEmployee {
    empCode: number;
}

interface IManager extends IPerson, IEmployee {
    designation: string;
}

let manager: IManager = {
    name: 'John',
    age: 30,
    empCode: 123,
    designation: 'Manager'
};

console.log(manager.name); // Output: John
console.log(manager.empCode); // Output: 123
console.log(manager.designation); // Output: Manager

在上面的示例中，定义了三个接口 IPerson、IEmployee 和 IManager，IManager 接口继承自 IPerson 和 IEmployee 接口，实现了多重继承的功能。