TypeScript Herencia de clases y polimorfismo

TypeScript admite las características de herencia y polimorfismo de la programación orientada a objetos.

Diagrama SVG: jerarquía de herencia de clases Fondo Título Estructura de jerarquía de herencia de clases Clase padre Animal Animal (clase padre) Flecha hacia la subclase Subclase Dog Dog (subclase) extends Animal Subclase Cat Cat (subclase) extends Animal Flecha hacia la instancia Instancia Instancia de Dog Instancia de Cat Explicación del lado derecho Características de herencia • Herencia con extends • Llamada a super() • Sobrescritura de métodos • Polimorfismo • instanceof Marcador de flecha

Herencia de clases

La herencia se implementa usando la palabra clave extends.

Ejemplo

class Animal {
    name: string;

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

    speak(): void {
        console.log(this.name + emitir sonido);
    }
}

class Dog extends Animal {
    breed: string;

    constructor(name: string, breed: string) {
        super(name);  // Llamar al constructor de la clase padre
        this.breed = breed;
    }

    speak(): void {
        console.log(this.name + ¡Guau guau guau!);
    }
}

var dog = new Dog("Fortuna", Golden retriever);
dog.speak();

Resultado de la ejecución:

¡Wangcai guau guau guau!

La palabra clave super

super se usa para llamar a los métodos y al constructor de la clase padre.

Ejemplo

class Shape {
    color: string;

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

    describe(): string {
        return Esta es una + this.color + figura;
    }
}

class Circle extends Shape {
    radius: number;

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

    // Sobrescribir el método de la clase padre
    describe(): string {
        // Llamar al método de la clase padre y extender
        return super.describe() + , el radio es + this.radius;
    }

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

var circle = new Circle(roja, 5);
console.log(circle.describe());
console.log(Área: + circle.area().toFixed(2));

Resultado de la ejecución:

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

Polimorfismo

Las instancias de las subclases se pueden asignar al tipo de la clase padre.

Ejemplo

class Animal {
    name: string;
    constructor(name: string) { this.name = name; }
    speak(): void {
        console.log(this.name + emitir sonido);
    }
}

class Cat extends Animal {
    speak(): void {
        console.log(this.name + ¡Miau miau miau!);
    }
}

class Dog extends Animal {
    speak(): void {
        console.log(this.name + ¡Guau guau guau!);
    }
}

// Polimorfismo: el array almacena instancias de diferentes subclases
var animals: Animal[] = [
    new Cat(Blanquito),
    new Dog("Fortuna"),
    new Animal(animal)
];

// Llamar al mismo método, diferentes subclases tienen diferentes implementaciones
for (var _i = 0, animals_1 = animals; _i < animals_1.length; _i++) {
    var animal = animals_1[_i];
    animal.speak();
}

Resultado de la ejecución:

¡Xiaobai miau miau miau!
¡Wangcai guau guau guau!
Los animales hacen sonidos.

Comprobación instanceof

Usa instanceof para comprobar el tipo de la instancia.

Ejemplo

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(Área del rectángulo: + shape.area());
    } else if (shape instanceof Circle) {
        console.log(Área del círculo: + shape.area().toFixed(2));
    }
}

Resultado de la ejecución:

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

Miembro protected

Los miembros protected son visibles en las subclases.

Ejemplo

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 {
        // Se puede acceder al miembro protected
        return Yo soy + this.name + , en + this.department + trabajo;
    }
}

var emp = new Employee("Alice", Departamento de tecnología);
console.log(emp.introduce());

// console.log(emp.name); // Error: protected no es accesible desde fuera

Resultado de la ejecución:

我是 Alice，在 技术部 工作

Resumen

  • Herencia:Palabra clave extends
  • super：Llamar a la clase padre
  • Polimorfismo:Misma interfaz, diferentes implementaciones
  • protected：Visible en la subclase
Otras extensiones