Herencia y polimorfismo en TypeScript

La HERENCIA es un mecanismo que nos permite definir una nueva clase basada en una clase existente. La clase existente se conoce como la clase base o superclase, y la nueva clase se conoce como la clase derivada o subclase.

La subclase hereda todas las propiedades y métodos de la superclase y puede agregar nuevos atributos y comportamientos según sea necesario.

En TypeScript, podemos lograr la herencia utilizando la palabra clave extends. La clase base define las propiedades y métodos comunes, mientras que la clase derivada extiende y especializa estos miembros.

Vamos a verlo con un ejemplo:

// Clase base
class Animal {
    constructor(public nombre: string) {}

    hacerSonido(): void {
        console.log(`${this.nombre} hace un sonido.`);
    }
}

// Clase derivada
class Perro extends Animal {
    ladrar(): void {
        console.log(`${this.nombre} está ladrando.`);
    }
}

const miPerro = new Perro("MiPerro");
miPerro.hacerSonido(); // Salida: MiPerro hace un sonido.
miPerro.ladrar();      // Salida: MiPerro está ladrando.

En este ejemplo,

• Perro hereda la propiedad nombre y el método hacerSonido de la clase Animal
• Añade su propio método ladrar

Sobrescritura de métodos

Una clase derivada puede sobrescribir métodos de la clase base utilizando la palabra clave override.

class Animal {
    constructor(public nombre: string) {}

    hacerSonido(): void {
        console.log(`${this.nombre} hace un sonido.`);
    }
}

class Gato extends Animal {
    override hacerSonido(): void {
        console.log(`${this.nombre} maúlla.`);
    }
}

const miGato = new Gato("Misi");
miGato.hacerSonido(); // Salida: Misi maúlla.

Aquí, el método hacerSonido en Gato sobrescribe la implementación del método hacerSonido en Animal.

Constructor y inicialización en herencia

Cuando una clase derivada tiene un constructor, generalmente es necesario llamar al constructor de la clase base para inicializar correctamente el objeto. Para ello empleamos la palabra clave super.

class Animal {
    constructor(public nombre: string) {}
}

class Perro extends Animal {
    constructor(nombre: string, public raza: string) {
        super(nombre); // Llama al constructor de la clase base
    }

    mostrarInfo(): void {
        console.log(`Nombre: ${this.nombre}, Raza: ${this.raza}`);
    }
}

const miPerro = new Perro("Rex", "Labrador");
miPerro.mostrarInfo(); // Salida: Nombre: Rex, Raza: Labrador

En este ejemplo, el constructor de Perro llama al constructor de Animal usando super para inicializar la propiedad nombre.

Polimorfismo en Typescript

El POLIMORFISMO es otro concepto clave en la programación orientada a objetos. Nos permite tratar objetos de diferentes clases de manera uniforme, siempre y cuando compartan una interfaz o superclase común.

En Typescript, podemos lograr el polimorfismo utilizando interfaces. Veamos un ejemplo utilizando una interfaz:

interface Animal {
  hacerSonido(): void;
}

class Dog implements Animal {
  hacerSonido() {
    console.log("El perro ladra");
  }
}

class Cat implements Animal {
  hacerSonido() {
    console.log("El gato maulla");
  }
}

function makeAnimalSound(animal: Animal) {
  animal.hacerSonido();
}

const myDog = new Dog();
const myCat = new Cat();

makeAnimalSound(myDog); // Output: "El perro ladra"
makeAnimalSound(myCat); // Output: "El gato maulla"

En este ejemplo

• Creamos una interfaz Animal con un método hacerSonido.
• Luego, creamos las clases Dog y Cat que implementan la interfaz Animal.
• Finalmente, creamos una función makeAnimalSound que acepta un parámetro de tipo Animal y llama al método hacerSonido del objeto pasado.