4. Polimorfismo de sobrecarga

4.1 SOBRECARGA:

Varias implementaciones del mismo método con distintos parámetros (cambio de interfaz). Muy habitual en constructores.
› Es aquí donde realmente se aprecia los beneficios del polimorfismo.
› Sobrecargando el constructor conseguimos dotar a la clase de flexibilidad.
› Java permite que varios métodos dentro de una clase se llamen igual, siempre y cuando su lista de parámetros sea distinta. Por ejemplo así, se podría definir la siguiente clase:

Dos funciones, procedimientos u operadores que se llaman igual se distinguen por el tipo de sus argumentos o por el número de sus argumentos.

"SumaGenerica" que aglutinara las sumas de todos los tipos primitivos:
class SumaGenerica {
int suma (int a, int b) {
return a+b; }
double suma (double a, double b) {
return a+b; } }

En este caso se dice que el método está sobrecargado y el proceso de definir un método así se conoce como sobrecarga del método. La sobrecarga de métodos es una de las maneras en que Java implementa el polimorfismo.



4.2 SOBREESCRITURAS DE MÉTODOS:

Ø Una subclase puede modificar los métodos que ha heredado del padre.
Una subclase puede crear un método con diferente funcionalidad al método del padre, pero con el mismo:
l Nombre
l Tipo de retorno
l Lista de argumentos

Ø Llamada de métodos virtuales.
Empleado e = new Jefe;
e.getDetails ( );

Se comprueba el tipo de la referencia estática (Empleado) en tiempo de compilación y el tipo de la referencia dinámica (Jefe) en tiempo de ejecución.
¿Cual de los getDetails () se ejecutará, el de la clase Empleado o el de la clase Jefe?
Se obtiene el comportamiento del método asociado a la clase de la variable y no el comportamiento asociado al tipo de la variable en el compilador. Por tanto se ejecuta e.getDetails () ejecutando el del tipo real del objeto, es decir el método de Jefe. A este comportamiento se le suele llamar invocación de métodos virtuales. Hay una diferencia muy importante entre C++ y Java. En C++, sólo se modifica el comportamiento si se define el método como virtual. En los lenguajes OO puros, esto es normal, pero con ello C++ gana tiempo en ejecución.

Para poder sobreescribir métodos en las clases descendientes se debe verificar:
l El tipo de retorno de los dos métodos ha de ser igual.
l El método de la subclase no puede ser menos accesible que el de la clase padre.
l El método de la subclase no puede provocar más excepciones que el método del padre.

Sobreescritura de métodos:

public class Padre {
public void método (){ }
}
public class Hijo extends Padre {
public void método (){ }
\\no puede ser private
}
public class OtraClase{
public void otroMetodo () {
Padre p1 = new Padre ();
Padre p2 = new Hijo ();
p1.método();
p2.método(); }}


EJEMPLO:

int a=5;
int b=6;
int c=a+b; // c vale 11
String a=“Ho”;
String b=“la”;
String c=a+b; // c vale “Hola”


EJEMPLO:

class Gato {
public Gato (){…}
public Gato (String nombre){…}
public void comer (Planta planta){…} // método 1
public void comer (Planta planta, int x, int y){…} //2
public void comer (ComidaGatos comida){…} //3
}

Ejemplo
class Gato {
public Gato () {…}
public Gato (String nombre){…}
public void comer (Planta planta){…} // método 1
public void comer (Planta planta, int x, int y){…} //2
public void comer (Comida Gatos comida){…} //3
}
Gato gato = new Gato (“Ruffy2);
Planta planta = new Planta ();
ComidaGatos comida = new ComidaGatos();
gato.comer (planta); //ejecuta método 1
gato.comer (planta, 3,4); //ejecuta método 2
gato.comer (comida); // ejecuta el método 3

Class Gato {
public Gato (){…}
public Gato (String nombre){…}
public void comer (Planta planta) {…} // metodo 1
public void comer (Geranio planta) {…} // método 2
public void comer (Roedor rt) {…} // método 3
public void comer (Object o) {…} // método 4
}
class Geranio extends Planta{…};
Gato gato=new Gato();;
Geranio geranio= new Geranio ();
gato. comer (geranio);
/* ¿Método 1, 2 o 4? “Geranio” es una Planta
y un “Geranio” y un “Object”. En teoría todos
los métodos son factibles ¿por cual se
decanta? */