TypeScript - 继承

TypeScript 中的继承允许我们重用单个类的属性和方法到其他类。因此，它通过允许重用不同类的代码来提高代码可读性。

TypeScript 是一种面向对象的编程语言，它支持 OOP 的所有特性。面向对象编程有四个主要支柱，继承是其中之一。

TypeScript 主要支持两种类型的继承：单类继承和多级继承。我们将在本章中探讨每一种。

单类继承

在单类继承中，一个类继承另一个类的属性。继承其他类属性的类称为基类或子类。其属性被继承的类称为父类或超类。

您可以使用 'extend' 关键字在 TypeScript 中实现继承。

语法

您可以按照以下语法使用单类继承。

class Child extends Parent {
    // Define properties and methods for child class
}

在上面的语法中，我们在子类和父类名称之间使用了 'extends' 关键字。

示例

在下面的代码中，我们定义了 'Vehicle' 类，其中包含 'getType()' 方法，返回车辆类型。

class Vehicle {
    getType() {
        return "Vehicle";
    }
}

// Define a class Car that extends Vehicle
class Car extends Vehicle {
    carName: string = "Innova";
    getCarName() {
        return this.carName;
    }
}

// Create an object of Car class
let car = new Car();
console.log(car.getType()); // Output: Vehicle
console.log(car.getCarName()); // Output: Innova

编译后，它将生成以下 JavaScript 代码。

class Vehicle {
    getType() {
        return "Vehicle";
    }
}
// Define a class Car that extends Vehicle
class Car extends Vehicle {
    constructor() {
        super(...arguments);
        this.carName = "Innova";
    }
    getCarName() {
        return this.carName;
    }
}
// Create an object of Car class
let car = new Car();
console.log(car.getType()); // Output: Vehicle
console.log(car.getCarName()); // Output: Innova

输出

Vehicle
Innova

super 关键字

super 关键字用于调用父类的构造函数或访问并调用父类的方法。

语法

您可以按照以下语法使用 super 关键字在子类中调用父类的构造函数和方法。

class Child extends Parent {
    constructor() {
        super();  // To call the constructor of the parent class
    }
    super.method_name(); // To call method of the parent class
}

在上面的语法中，我们在子类的构造函数内使用了 'super()' 来调用父类的构造函数。

在 'super.method_name()' 中，method_name 是父类方法的名称。

示例

在下面的代码中，我们定义了 Person 类，它包含 'name' 属性，并在构造函数 () 方法中初始化它。display() 方法打印 name 属性的值。

class Person {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
    display(): void {
        console.log(this.name);
    }
}

// Employee class is inheriting the Person class
class Employee extends Person {
    empCode: number;
    constructor(name: string, code: number) {
        super(name);
        this.empCode = code;
    }
    show(): void {
        super.display();
    }
}
// Creating the object of Employee class
let emp = new Employee("Sam", 123);
emp.show(); // Sam

编译后，它将生成以下 JavaScript 代码。

class Person {
    constructor(name) {
        this.name = name;
    }
    display() {
        console.log(this.name);
    }
}
// Employee class is inheriting the Person class
class Employee extends Person {
    constructor(name, code) {
        super(name);
        this.empCode = code;
    }
    show() {
        super.display();
    }
}
// Creating the object of Employee class
let emp = new Employee("Sam", 123);
emp.show(); // Sam

输出

上面的代码示例将产生以下结果：

Sam

方法重写

方法重写概念允许您在子类中重写父类特定方法的代码。这样，您可以在父类和子类中拥有同名但功能不同的方法。

示例

在下面的代码中，Animal 类有一个 move() 方法，适用于任何动物。之后，我们用 Animal 类扩展了 Dog 类。Dog 类有它自己的 move() 方法，这就是我们进行方法重写的方式。

class Animal {
    move() {
        console.log("Animal is moving");
    }
}

// Dog class is inheriting Animal class
class Dog extends Animal {
    // Method overriding
    move() {
        console.log("Dog is moving");
    }
}

let dog = new Dog();
dog.move(); // Output: Dog is moving

编译后，它将生成相同的 JavaScript 代码。

输出

上面的代码示例将产生以下结果：

Dog is moving

多级继承

多级继承允许您继承父类的属性，而父类也继承另一个类。

示例

在下面的代码中，Parrot 类继承了 Bird 类的属性和方法，而 Bird 类继承了 Animal 类的属性和方法。但是，在实际开发中，您可能会有更多层次的多级继承。

class Animal {
    // Move method
    move() {
        console.log('This animal moves');
    }
}

// Bird class extends Animal class
class Bird extends Animal {
    // Bird can fly
    fly() {
        console.log('This bird flies');
    }
}

// Parrot class inherits the Bird class
class Parrot extends Bird {
    // Parrot can speak
    speak() {
        console.log('The parrot speaks');
    }
}

// Creating an instance of the Parrot class
let P1 = new Parrot();
P1.speak();

编译后，它将生成相同的 JavaScript 代码。

输出

上面的代码示例将产生以下结果：

The parrot speaks

多继承、层次继承和混合继承也受一些面向对象编程语言支持，但不被 TypeScript 支持。您可以使用接口或基于原型的继承来实现多继承。

打印页面