Nov 06

¿Polimorfismo o sobrecarga?

El siguiente ejemplo ¿es polimorfismo o sobrecarga de método?

Vamos con una clase Padre y una clase Hijo, ambas con el método metodo() que admite un parámetro. Vamos a hacer que el parámetro que admita Padre.metodo() sea Object y el que admita Hijo.metodo() sea String -o cualquier hijo de Object-.

public class Padre
{
    public void metodo(Object parametro)
    {
        System.out.println("soy padre");
    }
}

public class Hijo extends Padre
{
    public void metodo (String parametro)
    {
        System.out.println("soy hijo");
    }
}

Ahora hagamos el siguiente main() tonto de prueba

    public static void main(String[] args)
    {
        Padre p = new Hijo();
        p.metodo("hola");
       
        Hijo h = new Hijo();
        h.metodo("hola");
    }

¿Cual es el resultado de eso?. Pues el primer p.metodo("hola") llama al método del padre mientras que el segundo h.metodo("hola") llama al método del hijo. Es decir, el que se llame a un método u otro depende del tipo de variable que tengamos y no del objeto que hay realmente dentro de esa variable. En ambos casos se hace un new de Hijo, es decir, en ambos casos tenemos el mismo tipo de objeto, pero en el primer caso lo guardamos en una variable de tipo Padre mientras que en el segundo en una de tipo Hijo.

Este ejemplo en realidad es sobrecarga de métodos y no polimorfismo. Padre sólo tiene un método que admite Object. Hijo en realidad tiene dos, uno que admite Object -heredado de Padre- y otro que admite String -sobrecarga-. Si la variable p es tipo Padre, sólo se puede llamar al único metodo() que tiene, el de Object. Si la variable h es tipo Hijo, el tipo de parámetro -String en este caso-, decidirá si se llama a uno u otro.

Con este tema me he tropezado de mala manera. Me había hecho una especie de clase Lista genérica con métodos para Object. En un momento dado quise hacer una Lista específica de Integer con algunos métodos más, así que heredé de la clase Lista genérica de Object y redefiní los métodos addElement() y similares para que admitieran Integer en los parámetros. Pues bien, allí donde guardaba mi Lista de Integer en una varible tipo Lista de Object, no se llamaba a los métodos de Lista de Integer, sino a los de la clase padre.

Entradas relacionadas:

  • No hay entradas relacionadas.

5 Responses to “¿Polimorfismo o sobrecarga?”

  1. DaniP Says:

    Pero…. siempre podrías hacer un:

    if (p instanceof Hijo)
    ((Hijo) p).metodo(“hola”);
    else
    p.metodo(“hola”);

    Sé que no te da la flexibilidad de implementación que te gustaría, pero por lo menos funcionaría allí donde quisieras ser más específico.

    :/

  2. Chuidiang Says:

    Soluciones hay, lo que pasa es que me choqué con ello y me dio un pequeño quebradero de cabeza hasta que caí en la cuenta. Al final lo que hice fue declarar el método en el hijo también con Object y comprobar dentro del método si es del tipo que quiero. Si no es del tipo que quiero, llamo al padre.

    Se bueno.

  3. Joso Says:

    Holas, programo hace muy poco tiempo pero tengo entendido que el objeto p utiliza el parametro como un Object a menos que se haga un cast:

    ((Hijo) p).metodo(“Hola”); asi trabajaria como String

    p.metodo(“Hola”); asi lo tomaria como object

    esop. Saludos.

  4. william Says:

    Creo que el polimorfismo o sobrecarga son los mismo, una clase puede tener un mismo nombre de contructor para el caso de uno o más constructores y diferentes tipos de parámetros,para el caso de metodos de acceso o de modificación pueden ser del mismo nombre de metodo y difentes tipos de parámetros.

  5. Jose Says:

    William tiene razon, las ensenanzas antiguas no es lo que son en la actualidad, el poliformismo si o si lleva sobrecarga de metodos, por lo que es una sobrecarga en toda regla…

Leave a Reply