POO: Sobrecarga VS Polimorfismo

Una de las novedades que uno se encuentra al comenzar a programar en Java (y tambien en otros lenguajes de la POO) son las ventajas de la sobrecarga y el polimorfismo. Al principio, para quienes veníamos de un lenguaje muy estructurado como Pascal, estos dos conceptos resultan un poco chocantes. Difusos. Vamos a repasarlos un poco.

Sobrecarga
Imaginemos una clase “Monedero” que modele un monedero que contiene un saldo. Cuando creamos un monedero, puede que se cree vacío o con una cantidad determinada que nosotros le pasemos:
// Clase que modela un monedero
class Monedero {

   // Atributos
   private int saldo = 0;

   // Constructores
   public Monedero (int x){    // Asigna un saldo inicial al monedero
     this.saldo = x;
   }

   public Monedero (){    // Asigna el saldo inicial por defecto
   }

}

Cuando invoquemos al constructor de monedero tendremos dos posibilidades, invocarlo con o sin parámetro, y automáticamente el lenguaje se encargará de utilizar un método u otro según corresponda. En definitiva:
Monedero miMonedero = new Monedero (1000);
Creará el objeto miMonedero que contendrá un valor de 1000. Y:
Monedero tuMonedero = new Monedero ();
Creará un segundo objeto, tuMonedero, y este utilizará el valor por defecto, que por defecto es 0 (que es como se inicializó el atributo saldo de la clase).

La conclusión es que:

La sobrecarga permite dar nombres iguales a métodos que reciben distintos parámetros y que, aplicados a un mismo objeto, producirían efectos diferentes. El método a usar se decide automáticamente según el número de parámetros con el que se invoque.

Polimorfismo
Entonces… ¿Que es eso del polimorfismo?
En la sobrecarga un método u otro se invocaba atendiendo a sus parámetros, lo que resultaba en un “polimorfismo aparente”, ya que no era totalmente automática la decisión de que método usar.
El programador debía llamarlo con el número correcto de parámetros para el método que quisiese usar. Cuando queríamos crear un monedero con un saldo inicial, llamábamos al constructor pasándole el parámetro del saldo; y no indicábamos ningún parámetro para referirnos al otro constructor. Así el lenguaje sabía a qué nos referíamos a pesar de que se llamasen igual.

El “polimorfismo puro” va un paso más allá. Se pretende que en diferentes clases pueda haber métodos con el mismo nombre y parámetros y que se decida, según el objeto sobre el que se invoque el método, si utilizar uno u otro. Si tenemos una clase Persona y una clase Perro, puede ser útil un método “mostrarDatos”. En más detalle:

public void mostrarDatos (){
   // cuerpo del método
}

¿Como podríamos diferenciar un método de otro? Deben aplicarse a objetos de distinta clase e incluso están implementados de forma diferente:

// Clase que modela una persona
class Persona {

   // Atributos
   private String nombre = "";
   private int edad = 0;

...

   // Consultas
   public void mostrarDatos (){
     System.out.println ("Nombre: "+this.nombre);
     System.out.println ("Edad: "+this.edad);
   }

}

Y…

// Clase que modela un perro
class Perro {

   // Atributos
   private String nombre = "";
   private String raza = "";

...

   // Consultas
   public void mostrarDatos (){
     System.out.println ("Nombre: "+this.nombre);
     System.out.println ("Raza: "+this.raza);
   }

}

En este caso, el polimorfismo puro decidirá, según de qué objeto se trate, qué método emplear. Incluso aunque no sea conocido de antemano. Por ejemplo, ambas clases pueden ser subclases de “Mamifero”. Si un usuario nos reclama mostrar los datos de un objeto de clase “Mamífero”, se comprobará a qué subtipo pertenece para tomar un método u otro, por ejemplo en el codigo siguiente (el método estático “preguntarMamifero” devuelve un objeto de una subclase de “Mamifero”):

Mamifero m = Mamifero.preguntarMamifero();
m.mostrarDatos();

Podemos concluir que realmente:

El polimorfismo (o polimorfismo puro), es la capacidad del lenguaje de decidir de forma dinámica a qué método recurrir si hay varios con igual cabecera, no atendiendo a sus parámetros sino al objeto sobre el que es invocado; pudiendo dar una implementación diferente para cada clase de objetos de forma transparente al resto del programa.

Anuncios

6 pensamientos en “POO: Sobrecarga VS Polimorfismo

  1. Me gustó como explicaste de forma muy clara la diferencia entre estos dos conceptos muchas veces confundidos. Creo que agregaría, aunque se sobre entiende de forma implicita, que el Polimorfismo nos permite la Redefinición de Métodos, práctica que resulta especialmente útil al encarar Herencia,

    Me gusta

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s