Polimorfismo

10.1 Fundamentos do polimorfismo

Polimorfismo é um dos conceitos chave da programação orientada a objetos (POO). De forma geral, o polimorfismo permite que objetos de diferentes classes processem dados usando a mesma interface. No contexto do JavaScript, isso significa que objetos diferentes podem ter métodos com os mesmos nomes, e esses métodos podem ser chamados nos objetos sem conhecer seu tipo específico.

Tipos de polimorfismo

No JavaScript, os principais tipos de polimorfismo são:

1. Polimorfismo ad-hoc (ad-hoc polymorphism):

• Polimorfismo de métodos, chamada de métodos com o mesmo nome para objetos de tipos diferentes
• Exemplos incluem sobrecarga de funções e operadores (o que não é suportado diretamente no JavaScript, mas pode ser simulado)

2. Polimorfismo de subtipos (Subtype polymorphism):

• Polimorfismo de subtipos ou inclusão, quando objetos de diferentes classes que herdam de uma mesma classe base podem ser tratados como objetos da classe base
• Este é o principal tipo de polimorfismo, implementado através de herança e interfaces

Vantagens do polimorfismo:

1. Simplificação do código: o polimorfismo permite escrever código mais flexível e genérico, que pode trabalhar com diferentes tipos de objetos sem conhecer seus tipos específicos.
2. Expansibilidade: o polimorfismo facilita a adição de novos tipos e comportamentos ao sistema sem a necessidade de modificar o código existente.
3. Manutenção: o polimorfismo promove uma melhor separação de responsabilidades e aumenta a legibilidade e a manutenção do código.

10.2 Exemplos de polimorfismo em JavaScript

Polimorfismo de subtipos através de herança

Exemplo 1: Manipulação de diferentes tipos de objetos através de uma única interface

Neste exemplo, a função playWithAnimal recebe um objeto do tipo Animal e chama o método makeSound. Os objetos Dog e Cat, que herdam de Animal, sobrescrevem o método makeSound, e ao chamar o método em cada objeto, obtemos um resultado diferente.

    
      class Animal {
        makeSound() {
          console.log('Some generic sound');
        }
      }

      class Dog extends Animal {
        makeSound() {
          console.log('Woof!');
        }
      }

      class Cat extends Animal {
        makeSound() {
          console.log('Meow!');
        }
      }

      function playWithAnimal(animal) {
        animal.makeSound();
      }

      const dog = new Dog();
      const cat = new Cat();

      playWithAnimal(dog); // Saída: Woof!
      playWithAnimal(cat); // Saída: Meow!
    
  

10.3 Polimorfismo através de interfaces (Duck Typing)

No JavaScript, não há suporte embutido para interfaces, como em outras linguagens, como TypeScript ou Java. Em vez disso, usamos uma abordagem chamada "Duck Typing". Isso significa que um objeto é considerado conforme a interface se possuir os métodos e propriedades necessários, independentemente de seu tipo específico ou herança.

Exemplo 2: Uso de Duck Typing

Neste exemplo, a função takeOff aceita qualquer objeto que tenha o método fly. Os objetos Bird e Airplane implementam o método fly, e por isso podem ser passados para takeOff.

    
      class Bird {
        fly() {
          console.log('Flying...');
        }
      }

      class Airplane {
        fly() {
          console.log('Jet engine roaring...');
        }
      }

      function takeOff(flyingObject) {
        flyingObject.fly();
      }

      const bird = new Bird();
      const airplane = new Airplane();

      takeOff(bird);      // Saída: Flying...
      takeOff(airplane);  // Saída: Jet engine roaring...
    
  

10.4 Polimorfismo através de funções

No JavaScript, funções são objetos de primeira classe, e podem ser passadas e usadas para implementar comportamento polimórfico.

Exemplo 3: Polimorfismo através de funções

Neste exemplo, a função greet aceita outra função como argumento e a chama. Isso permite usar funções diferentes para realizar ações diferentes.

    
      function greetMorning() {
        console.log('Good morning!');
      }

      function greetEvening() {
        console.log('Good evening!');
      }

      function greet(greetingFunction) {
        greetingFunction();
      }

      greet(greetMorning); // Saída: Good morning!
      greet(greetEvening); // Saída: Good evening!
    
  

10.5 Polimorfismo através de sobrecarga de método (Simulação)

JavaScript não suporta sobrecarga de métodos diretamente, como algumas outras linguagens de programação. No entanto, é possível simular sobrecarga de métodos usando argumentos de função e verificando seus tipos.

Exemplo 4: Simulação de sobrecarga de método

Neste exemplo, o método add aceita dois argumentos e realiza ações diferentes dependendo de seus tipos. Se os argumentos são números, o método os soma. Se os argumentos são arrays, o método os concatena.

    
      class Calculator {
        add(a, b) {
          if (typeof a === 'number' && typeof b === 'number') {
            return a + b;
          } else if (Array.isArray(a) && Array.isArray(b)) {
            return a.concat(b);
          } else {
            throw new Error('Invalid arguments');
          }
        }
      }

      const calc = new Calculator();
      console.log(calc.add(1, 2));           // Saída: 3
      console.log(calc.add([1, 2], [3, 4])); // Saída: [1, 2, 3, 4]