Herança e Polimorfismo

Herança e polimorfismo são conceitos fundamentais da programação orientada a objetos (OOP) e são totalmente suportados pelo TypeScript. Esses conceitos permitem a criação de códigos mais reutilizáveis, organizados e flexíveis. Vamos explorar como a herança de classes e a sobrescrita de métodos funcionam em TypeScript.

Herança de Classes

A herança permite que uma classe (chamada de classe derivada ou subclasse) herde propriedades e métodos de outra classe (chamada de classe base ou superclasse). Isso promove a reutilização de código e a criação de hierarquias de classes.

Definindo uma Classe Base:

Vamos começar definindo uma classe base simples chamada Animal:

class Animal {
  name: string;

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

  makeSound(): void {
    console.log("Some generic animal sound");
  }
}

Criando uma Classe Derivada:

Agora, vamos criar uma classe derivada chamada Dog que herda de Animal:

class Dog extends Animal {
  constructor(name: string) {
    super(name); // Chama o construtor da classe base
  }

  makeSound(): void {
    console.log("Woof! Woof!");
  }
}

Neste exemplo, Dog herda todas as propriedades e métodos de Animal. A palavra-chave extends é usada para definir a herança, e o método super é chamado no construtor da subclasse para garantir que o construtor da classe base seja executado.

Sobrescrita de Métodos

A sobrescrita de métodos permite que uma subclasse forneça uma implementação específica de um método que já é definido na sua superclasse. Isso é útil para modificar ou estender o comportamento herdado.

Sobrescrita em Ação:

No exemplo acima, o método makeSound foi sobrescrito na classe Dog:

class Dog extends Animal {
  constructor(name: string) {
    super(name);
  }

  makeSound(): void {
    console.log("Woof! Woof!");
  }
}

Quando makeSound é chamado em uma instância de Dog, a implementação específica de Dog será executada, em vez da implementação genérica da classe Animal.

Polimorfismo:

O polimorfismo permite que uma função trate objetos de diferentes classes de forma uniforme. Em TypeScript, isso é geralmente alcançado através da herança e da sobrescrita de métodos.

Exemplo de Polimorfismo:

Vamos ver um exemplo de polimorfismo em ação:

class Animal {
  name: string;

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

  makeSound(): void {
    console.log("Some generic animal sound");
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name);
  }

  makeSound(): void {
    console.log("Woof! Woof!");
  }
}

class Cat extends Animal {
  constructor(name: string) {
    super(name);
  }

  makeSound(): void {
    console.log("Meow! Meow!");
  }
}

function makeAnimalsSound(animals: Animal[]) {
  animals.forEach((animal) => {
    animal.makeSound();
  });
}

const animals: Animal[] = [new Dog("Buddy"), new Cat("Whiskers")];
makeAnimalsSound(animals);

Neste exemplo, a função makeAnimalsSound aceita um array de Animal e chama o método makeSound em cada um deles. Graças ao polimorfismo, a implementação correta do método makeSound é chamada para cada objeto, seja ele um Dog ou um Cat.

Conclusão

A herança e o polimorfismo são poderosos conceitos da OOP que permitem criar estruturas de código mais flexíveis e reutilizáveis. Em TypeScript, esses conceitos são implementados de forma intuitiva e robusta, facilitando a criação de hierarquias de classes e a sobrescrita de métodos para personalizar o comportamento das subclasses. Usando esses recursos de maneira eficaz, você pode desenvolver aplicações mais eficientes e de fácil manutenção.