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.

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.

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

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"