Polimorfismo

O polimorfismo em TypeScript possibilita que diferentes classes respondam de formas distintas à mesma interface ou método, aumentando a flexibilidade do código. Esse conceito é central na orientação a objetos e ocorre principalmente por meio de herança (com sobrescrita de métodos) e interfaces, permitindo que funções e algoritmos operem sobre diferentes tipos relacionados de maneira uniforme.

O que é Polimorfismo?

• Permite que métodos de mesmo nome, definidos numa superclasse ou interface, sejam implementados de formas diferentes em subclasses.
• Um objeto de uma superclasse pode ser referenciado por instâncias de qualquer subclasse, e a chamada a métodos polimórficos resultará no comportamento da respectiva subclasse.

Exemplo com Herança: Sobrescrita de Métodos

class Funcionario {
  nome: string;
  constructor(nome: string) {
    this.nome = nome;
  }
  calcularSalario(): number {
    return 1000;
  }
}

class Gerente extends Funcionario {
  calcularSalario(): number {
    return 3000; // implementação diferente para gerente
  }
}

class Programador extends Funcionario {
  calcularSalario(): number {
    return 2000;
  }
}

const equipe: Funcionario[] = [
  new Gerente("Maria"),
  new Programador("Carlos"),
  new Programador("Ana")
];

equipe.forEach(f =>
  console.log(`${f.nome}: ${f.calcularSalario()}€`)
);
// Maria: 3000€
// Carlos: 2000€
// Ana: 2000€

Cada objeto responde à chamada de calcularSalario de acordo com sua classe específica (polimorfismo por sobrescrita).

Usando Interfaces para Polimorfismo

Interfaces definem contratos e permitem que funções operem sobre tipos diferentes, mas compatíveis:

interface Forma {
  area(): number;
}

class Quadrado implements Forma {
  constructor(public lado: number) {}
  area(): number {
    return this.lado * this.lado;
  }
}

class Circulo implements Forma {
  constructor(public raio: number) {}
  area(): number {
    return Math.PI * this.raio * this.raio;
  }
}

const formas: Forma[] = [
  new Quadrado(4),
  new Circulo(2)
];

formas.forEach(f => console.log(f.area()));
// 16
// 12.566370614359172

Diversas implementações de area() atendem o mesmo contrato Forma, demonstrando polimorfismo por interface.

Polimorfismo Paramétrico (Generics)

TypeScript permite criar funções polimórficas por tipo, chamadas de generics:

typescriptfunction imprimirArray<T>(arr: T[]): void {
  arr.forEach(item => console.log(item));
}

imprimirArray<number>([10, 20, 30]);
imprimirArray<string>(["a", "b", "c"]);

A função imprimirArray opera polimorficamente para qualquer tipo de array, mantendo a segurança de tipos.

Benefícios do Polimorfismo

• Flexibilidade: aceita vários tipos compatíveis.
• Reutilização: funções e algoritmos genéricos.
• Manutenção: fácil extensão do sistema sem alterar algoritmos existentes.

O polimorfismo torna o código mais desacoplado e preparado para mudanças e expansão, sendo fundamental na arquitetura orientada a objetos.

Se desejar, podem ser apresentados exercícios sobre identificação ou implementação de polimorfismo usando classes, interfaces ou generics.