Héritage de classe et polymorphisme TypeScript

TypeScript prend en charge les fonctionnalités d'héritage et de polymorphisme de la programmation orientée objet.

Diagramme SVG : hiérarchie d'héritage de classe Background Title Class inheritance hierarchy Parent class Animal Animal (parent class) Arrow to subclass Subclass Dog Dog (subclass) extends Animal Subclass Cat Cat (subclass) extends Animal Arrow to instance Instance Dog instance Cat instance Right-side description Inheritance characteristics • extends inheritance • super() call • Method overriding • Polymorphism • instanceof Arrow marker

Héritage de classe

Utilisez le mot-clé extends pour implémenter l'héritage.

Exemple

class Animal {
    name: string;

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

    speak(): void {
        console.log(this.name + " make a sound");
    }
}

class Dog extends Animal {
    breed: string;

    constructor(name: string, breed: string) {
        super(name);  // Appeler le constructeur de la classe parente
        this.breed = breed;
    }

    speak(): void {
        console.log(this.name + " Ouaf ouaf ouaf !");
    }
}

var dog = new Dog("Wangcai", "Golden Retriever");
dog.speak();

Sortie :

Wangcai woof woof woof!

mot-clé super

super est utilisé pour appeler les méthodes et le constructeur de la classe parente.

Exemple

class Shape {
    color: string;

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

    describe(): string {
        return "Ceci est une forme " + this.color + "";
    }
}

class Circle extends Shape {
    radius: number;

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

    // Redéfinir la méthode de la classe parente
    describe(): string {
        // Appeler la méthode de la classe parente et l'étendre
        return super.describe() + ", le rayon est " + this.radius;
    }

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

var circle = new Circle("red", 5);
console.log(circle.describe());
console.log("Aire : " + circle.area().toFixed(2));

Sortie :

这是一个 红色的图形,半径是 5
面积: 78.54

Polymorphisme

Une instance d'une sous-classe peut être affectée à un type de classe parente.

Exemple

class Animal {
    name: string;
    constructor(name: string) { this.name = name; }
    speak(): void {
        console.log(this.name + " make a sound");
    }
}

class Cat extends Animal {
    speak(): void {
        console.log(this.name + " Meow meow meow!");
    }
}

class Dog extends Animal {
    speak(): void {
        console.log(this.name + " Ouaf ouaf ouaf !");
    }
}

// Polymorphisme : stocker des instances de différentes sous-classes dans un tableau
var animals: Animal[] = [
    new Cat("Xiaobai"),
    new Dog("Wangcai"),
    new Animal("Animals")
];

// Appeler la même méthode ; les différentes sous-classes ont des implémentations différentes
for (var _i = 0, animals_1 = animals; _i < animals_1.length; _i++) {
    var animal = animals_1[_i];
    animal.speak();
}

Sortie :

Xiaobai meow meow meow!
Wangcai woof woof woof!
Animals make sounds.

vérification instanceof

Utilisez instanceof pour vérifier le type de l'instance.

Exemple

class Rectangle {
    width: number;
    height: number;
    constructor(width: number, height: number) {
        this.width = width;
        this.height = height;
    }
    area(): number {
        return this.width * this.height;
    }
}

class Circle {
    radius: number;
    constructor(radius: number) {
        this.radius = radius;
    }
    area(): number {
        return Math.PI * this.radius ** 2;
    }
}

var shapes = [new Rectangle(4, 5), new Circle(3)];

for (var _i = 0, shapes_1 = shapes; _i < shapes_1.length; _i++) {
    var shape = shapes_1[_i];
    if (shape instanceof Rectangle) {
        console.log("Aire du rectangle : " + shape.area());
    } else if (shape instanceof Circle) {
        console.log("Aire du cercle : " + shape.area().toFixed(2));
    }
}

Sortie :

矩形面积: 20
圆形面积: 28.27

membres protégés

Les membres protégés sont visibles dans les sous-classes.

Exemple

class Person {
    protected name: string;

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

class Employee extends Person {
    private department: string;

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

    public introduce(): string {
        // Peut accéder aux membres protégés
        return "Je suis " + this.name + ", dans " + this.department + " travaillant";
    }
}

var emp = new Employee("Alice", "Département Technologique");
console.log(emp.introduce());

// console.log(emp.name); // Erreur: protected n'est pas accessible depuis l'extérieur

Sortie :

我是 Alice,在 技术部 工作

Résumé

  • Héritage:mot-clé extends
  • super:Appeler la classe parente
  • Polymorphisme:Même interface, implémentations différentes
  • protected:Visible dans les sous-classes
Autres extensions