Clases: herencia

La herencia en TypeScript nos permite construir jerarquías de clases que reflejan relaciones de especialización entre ellas. Por ejemplo, podemos tener una clase base llamada Vehículo y derivar de ella otras clases como VehículoTerrestre, VehículoAéreo y VehículoMarítimo. Estas subclases heredan los atributos y métodos de la clase base, pero también pueden modificar o ampliar su comportamiento para adaptarse a sus particularidades.

Para establecer esta relación de herencia usamos la palabra clave extends. Así, al declarar class VehículoTerrestre extends Vehículo, indicamos que VehículoTerrestre es una especialización de Vehículo. Esto significa que VehículoTerrestre hereda todo lo que tiene Vehículo, pero puede redefinir métodos para cambiar su comportamiento.

Imaginemos que en la clase Vehículo tenemos un método llamado moverse que simplemente imprime un mensaje genérico:

class Vehículo {
  moverse() {
    console.log("El vehículo se ha movido mágicamente");
  }
}

Si instanciamos un objeto de esta clase y llamamos a moverse, veremos ese mensaje. Ahora, si creamos una subclase VehículoTerrestre que hereda de Vehículo, esta también tendrá el método moverse por herencia y, por defecto, se comportará igual:

class VehículoTerrestre extends Vehículo {}

Pero podemos redefinir el método moverse en VehículoTerrestre para que imprima algo más específico, como un sonido característico:

class VehículoTerrestre extends Vehículo {
  moverse() {
    console.log("Brum brum");
  }
}

Así, cuando llamemos a moverse en una instancia de VehículoTerrestre, veremos el mensaje personalizado. Esto nos permite adaptar el comportamiento de la clase base en las subclases.

Además, para mantener la conexión con la clase base y aprovechar su funcionalidad, podemos usar la palabra clave super. Esta referencia nos permite invocar métodos o constructores de la clase superior. Por ejemplo, dentro de VehículoTerrestre podemos llamar a super.moverse() para ejecutar el método original de Vehículo:

class VehículoTerrestre extends Vehículo {
  moverse() {
    super.moverse();
    console.log("Brum brum");
  }
}

De esta forma, combinamos el comportamiento de la clase base con el específico de la subclase.

Podemos aplicar esta misma lógica a otras subclases, como VehículoAéreo o VehículoMarítimo, cada una con su propia implementación de moverse que refleje sus características particulares:

class VehículoAéreo extends Vehículo {
  moverse() {
    console.log("Zuuum");
  }
}

class VehículoMarítimo extends Vehículo {
  moverse() {
    console.log("Ruido del mar");
  }
}

Otro aspecto importante en la herencia es el manejo de constructores y atributos. Supongamos que queremos que cada vehículo tenga un atributo fabricante de tipo string. Lo declaramos en la clase base y le añadimos un constructor para inicializarlo:

class Vehículo {
  fabricante: string;

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

  moverse() {
    console.log(`El vehículo ${this.fabricante} se ha movido mágicamente`);
  }
}

Cuando creamos una subclase que tiene su propio constructor, debemos llamar al constructor de la clase base usando super, pasando los parámetros necesarios. Por ejemplo, en VehículoTerrestre podemos añadir un atributo adicional tipo para especificar si es un tanque, una moto o un coche:

class VehículoTerrestre extends Vehículo {
  tipo: string;

  constructor(fabricante: string, tipo: string) {
    super(fabricante);
    this.tipo = tipo;
  }

  moverse() {
    console.log(`Brum, brum, hace mi ${this.tipo}`);
    super.moverse();
  }
}

Al instanciar un VehículoTerrestre, debemos proporcionar tanto el fabricante como el tipo:

const miMoto = new VehículoTerrestre("Yamaha", "moto");
miMoto.moverse();
// Salida:
// Brum, brum, hace mi moto
// El vehículo Yamaha se ha movido mágicamente

Este patrón garantiza que la información común se maneje en la clase base, mientras que las subclases pueden extenderla con detalles específicos. Además, TypeScript nos obliga a llamar al constructor de la clase superior cuando definimos un constructor en una subclase, asegurando que la inicialización se realice correctamente.

En resumen, la herencia en TypeScript nos permite crear estructuras jerárquicas de clases que comparten atributos y métodos, pero que también pueden especializar su comportamiento. Usando extends para definir la relación, super para acceder a la clase base y constructores que respetan esta jerarquía, podemos diseñar sistemas flexibles y reutilizables que reflejen las relaciones naturales entre objetos.