Polimorfismo

10.1 Fundamentos del polimorfismo

El polimorfismo es uno de los conceptos clave de la programación orientada a objetos (OOP). En términos generales, el polimorfismo permite a los objetos de diferentes clases manejar datos utilizando la misma interfaz. En el contexto de JavaScript, esto significa que diferentes objetos pueden tener métodos con los mismos nombres, y estos métodos pueden ser llamados sobre los objetos sin conocer su tipo específico.

Tipos de polimorfismo

En JavaScript, los principales tipos de polimorfismo son:

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

• Polimorfismo de métodos, invocación de métodos con el mismo nombre para objetos de diferentes tipos
• Los ejemplos incluyen sobrecarga de funciones y operadores (lo cual no se soporta directamente en JavaScript, pero puede ser simulado)

2. Polimorfismo de subtipo (Subtype polymorphism):

• Polimorfismo de subtipo o inclusión, cuando objetos de diferentes clases que heredan de la misma clase base pueden ser tratados como objetos de la clase base
• Este es el tipo principal de polimorfismo, implementado a través de la herencia e interfaces

Ventajas del polimorfismo:

1. Simplificación del código: el polimorfismo permite escribir código más flexible y general que puede trabajar con diferentes tipos de objetos sin conocer sus tipos específicos.
2. Extensibilidad: el polimorfismo facilita la adición de nuevos tipos y comportamientos al sistema sin necesidad de modificar el código existente.
3. Mantenimiento: el polimorfismo favorece una mejor separación de responsabilidades y aumenta la legibilidad y el mantenimiento del código.

10.2 Ejemplos de polimorfismo en JavaScript

Polimorfismo de subtipo a través de herencia

Ejemplo 1: Manejo de diferentes tipos de objetos usando una sola interfaz

En este ejemplo, la función playWithAnimal recibe un objeto del tipo Animal y llama al método makeSound. Los objetos Dog y Cat, que heredan de Animal, sobrescriben el método makeSound, y al llamar al método en cada objeto se obtiene un 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); // Imprimirá: Woof!
      playWithAnimal(cat); // Imprimirá: Meow!
    
  

10.3 Polimorfismo a través de interfaces (Duck Typing)

JavaScript no tiene soporte incorporado para interfaces como en otros lenguajes, como TypeScript o Java. En cambio, se utiliza un enfoque llamado "tipificación de pato" (Duck Typing). Esto significa que un objeto se considera que cumple con la interfaz si tiene los métodos y propiedades necesarios, independientemente de su tipo específico o herencia.

Ejemplo 2: Uso de la tipificación de pato

En este ejemplo, la función takeOff acepta cualquier objeto que tenga un método fly. Los objetos Bird y Airplane implementan el método fly, y por lo tanto se pueden pasar a 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);      // Imprimirá: Flying...
      takeOff(airplane);  // Imprimirá: Jet engine roaring...
    
  

10.4 Polimorfismo a través de funciones

En JavaScript, las funciones son objetos de primera clase, y se pueden pasar y usar para implementar un comportamiento polimórfico.

Ejemplo 3: Polimorfismo a través de funciones

En este ejemplo, la función greet acepta otra función como argumento y la llama. Esto permite utilizar diferentes funciones para realizar diferentes acciones.

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

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

      function greet(greetingFunction) {
        greetingFunction();
      }

      greet(greetMorning); // Imprimirá: Good morning!
      greet(greetEvening); // Imprimirá: Good evening!
    
  

10.5 Polimorfismo a través de sobrecarga de método (Simulación)

JavaScript no soporta sobrecarga de métodos directamente como algunos otros lenguajes de programación. Sin embargo, se puede simular la sobrecarga de métodos utilizando argumentos de función y verificando sus tipos.

Ejemplo 4: Simulación de sobrecarga de método

En este ejemplo, el método add acepta dos argumentos y realiza diferentes acciones dependiendo de sus tipos. Si los argumentos son números, el método los suma. Si los argumentos son arreglos, el método los 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));           // Imprimirá: 3
      console.log(calc.add([1, 2], [3, 4])); // Imprimirá: [1, 2, 3, 4]