Polimorfismo OOP: Fundamentos, Vinculación Dinámica y Dispatch

Este artículo es una explicación de conceptos sobre polimorfismo en programación orientada a objetos, incluyendo preguntas de examen y etiquetas.

En Resumen

El polimorfismo permite que una única llamada se aplique a diferentes implementaciones concretas, la selección del método adecuado depende del contexto y generalmente ocurre en tiempo de ejecución. El resultado es software flexible y extensible con menor acoplamiento a tipos concretos.

Descripción Técnica Compacta

El polimorfismo describe la capacidad de los objetos de responder de forma diferente a un mismo mensaje, según el tipo real del objeto. El núcleo es la vinculación dinámica, las llamadas a métodos se resuelven en tiempo de ejecución mediante tablas de dispatch (vtable) hacia la implementación adecuada.

Se distinguen tres tipos:

• Polimorfismo de subtipo a través de interfaces y herencia
• Polimorfismo paramétrico a través de genéricos
• Polimorfismo ad hoc a través de sobrecarga

El diseño polimórfico respalda el Principio Abierto Cerrado: las extensiones se realizan mediante nuevos tipos en lugar de modificar los existentes. El requisito previo es un contrato estable, las firmas y semántica deben mantenerse compatibles (Principio de Sustitución de Liskov).

En lenguajes tipados dinámicamente, surge un efecto similar mediante Duck Typing, el enfoque se centra en las operaciones disponibles en lugar de las relaciones de tipo estáticas.

Puntos Clave para Examen

• Vinculación dinámica en tiempo de ejecución a través de vtable
• Polimorfismo de subtipo a través de herencia e interfaces
• Sobrecarga de métodos (Overloading) como polimorfismo ad hoc
• Genéricos que permiten polimorfismo paramétrico
• Principio Abierto Cerrado mediante diseño polimórfico
• Principio de Sustitución de Liskov como requisito previo
• Duck Typing en lenguajes dinámicos
• Mecanismos de dispatch para resolución de métodos

Componentes Clave

1. Vinculación estática: llamada a método determinada en tiempo de compilación
2. Vinculación dinámica: llamada a método resuelta en tiempo de ejecución
3. Tabla de Métodos Virtuales (vtable): tabla de dispatch para llamadas polimórficas
4. Sobrescritura de métodos: reemplazar en subclases
5. Sobrecarga de métodos: múltiples métodos con el mismo nombre
6. Genéricos: programación independiente del tipo
7. Polimorfismo de interface: diferentes implementaciones de una interface
8. Duck Typing: “Si camina como un pato y grazna como un pato…”

Ejemplo Práctico

// Ejemplo: diferentes formas de polimorfismo
interface Zahlungsmethode {
    void bezahlen(double betrag);
}

class Kreditkarte implements Zahlungsmethode {
    @Override
    public void bezahlen(double betrag) {
        System.out.println("Kreditkarte: " + betrag + "€ belastet");
    }
}

class PayPal implements Zahlungsmethode {
    @Override
    public void bezahlen(double betrag) {
        System.out.println("PayPal: " + betrag + "€ überwiesen");
    }
}

// Genéricos (polimorfismo paramétrico)
class Box<T> {
    private T inhalt;
    
    public void setze(T inhalt) {
        this.inhalt = inhalt;
    }
    
    public T hole() {
        return inhalt;
    }
}

// Sobrecarga de métodos (polimorfismo ad hoc)
class Rechner {
    public int addiere(int a, int b) {
        return a + b;
    }
    
    public double addiere(double a, double b) {
        return a + b + 0.1; // Service-Gebühr
    }
    
    public String addiere(String a, String b) {
        return a + " " + b;
    }
}

// Polimorfismo en acción
public class Main {
    public static void main(String[] args) {
        // Polimorfismo de subtipo
        Zahlungsmethode[] methoden = {
            new Kreditkarte(), 
            new PayPal()
        };
        
        for (Zahlungsmethode methode : methoden) {
            methode.bezahlen(100.0); // Vinculación dinámica
        }
        
        // Genéricos
        Box<String> textBox = new Box<>();
        Box<Integer> zahlBox = new Box<>();
        
        // Sobrecarga
        Rechner rechner = new Rechner();
        System.out.println(rechner.addiere(1, 2));           // 3
        System.out.println(rechner.addiere(1.5, 2.5));       // 4.1
        System.out.println(rechner.addiere("Hallo", "Welt")); // "Hallo Welt"
    }
}

Ventajas y Desventajas

Ventajas

• Flexibilidad: tratamiento unificado de diferentes tipos
• Extensibilidad: nuevas implementaciones sin modificar código existente
• Mantenibilidad: menor acoplamiento entre componentes
• Reutilización: algoritmos genéricos y estructuras de datos

Desventajas

• Sobrecarga de rendimiento: la vinculación dinámica consume tiempo
• Complejidad: más difícil de entender y depurar
• Errores en tiempo de ejecución: problemas de tipo se detectan solo en ejecución
• Consumo de memoria: vtable y objetos adicionales

Preguntas Frecuentes de Examen

1. ¿Cuál es la diferencia entre sobrecarga y sobrescritura? Sobrecarga: el mismo nombre de método con parámetros diferentes. Sobrescritura: un método en una subclase reemplaza el método de la clase base.

2. ¿Cómo funciona la vinculación dinámica? En tiempo de ejecución, se utiliza la vtable para llamar al método adecuado basándose en el tipo de objeto real.

3. ¿Qué es Duck Typing? “Si camina como un pato y grazna como un pato, entonces es un pato” - el enfoque se centra en los métodos disponibles en lugar de los tipos estáticos.

4. ¿Por qué el polimorfismo respalda el Principio Abierto Cerrado? La nueva funcionalidad se puede agregar mediante nuevos tipos, sin modificar el código existente.

Fuentes Más Importantes

1. https://de.wikipedia.org/wiki/Polymorphie_(Programmierung)
2. https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html
3. https://refactoring.guru/de/design-patterns/strategy

---

Continúa en la Ruta de Aprendizaje OOP

El siguiente artículo en la ruta de aprendizaje OOP trata sobre OOP Dispatch: Vinculación Dinámica, Single & Double Dispatch — cómo el dispatch elige implementaciones de métodos en tiempo de ejecución.

Literatura Recomendada: Programación Orientada a Objetos