Sobrecarga de Mtodos.

(overloading)
Un mtodo sobrecargado se utiliza para reutilizar el nombre de un mtodo pero con diferentes
argumentos (opcionalmente un tipo diferente de retorno). Las reglas para sobrecargar un mtodo
son las siguientes:
+ Los mtodos sobrecargados debeb de cambiar la lista de argumentos.
+ Pueden cambiar el tipo de retorno.
+ Pueden cambiar el modificador de acceso.
+ Pueden declarar nuevas o ms amplias excepciones.
+ Un mtodo puede ser sobrecargado en la misma clase o en una subclase.
Veamos un mtodo que se desea sobrecargar:
public void cambiarTamano(int tamano, String nombre, float patron){ }
Los siguientes mtodos son sobrecargas legales del mtodo cambiarTamano():
public void cambiarTamano(int tamano, String nombre){}
public int cambiarTamano(int tamano, float patron){}
public void cambiarTamano(float patron, String nombre) throws IOException{}
Cmo invocar un mtodo sobrecargado::
Lo que define qu mtodo es el que se va a llamar son los argumentos que se envan al mismo
durante la llamada. Si se invoca a un mtodo con un String como argumento, se ejecutar el
mtodo que tome un String como argumento, si se manda a llamar al mismo mtodo pero con un
float como argumento, se ejecutar el mtodo que tome un float como argumento y as
sucesivamente. Si se invoca a un mtodo con un argumento que no es definido en ninguna de las
versiones sobrecargadas entonces el compilador arrojar un mensaje de error.
Ejemplo de una clase con un mtodo sobrecargado:
public class Sobrecarga {
public void Numeros(int x, int y){
System.out.println("Mtodo que recibe enteros.");
}
public void Numeros(double x, double y){
System.out.println("Mtodo que recibe flotantes.");
}
public void Numeros(String cadena){
System.out.println("Mtodo que recibe una cadena: "+ cadena);
}
public static void main (String... args){
Sobrecarga s = new Sobrecarga();
int a = 1;
int b = 2;
s.Numeros(a,b);
s.Numeros(3.2,5.7);
s.Numeros("Monillo007");
}
}

Al ejecutar el cdigo anterior obtendremos lo siguiente:

Mtodo que recibe enteros.
Mtodo que recibe flotantes.
Mtodo que recibe una cadena: Monillo007
Al utilizar objetos en lugar de tipos primitivos o cadenas se vuelve ms interesante. Veamos lo que
sucede cuando se tiene un mtodo sobrecargado que en una de sus versiones toma un Animal
como parmetro y en otra un Caballo.
class Animal { }
class Caballo extends Animal{ }
class Animales{
public void MetodoSobrecargado(Animal a){
System.out.println("Mtodo de parmetro Animal...");
}
public void MetodoSobrecargado(Caballo c){
System.out.println("Mtodo de parmetro Caballo...");
}
public static void main(String... args){
Animales as = new Animales();
Animal objetoAnimal = new Animal();
Caballo objetoCaballo = new Caballo();
as.MetodoSobrecargado(objetoAnimal);
as.MetodoSobrecargado(objetoCaballo);
}
}
Al ejecutar el cdigo anterior obtenemos:
Mtodo de parmetro Animal...
Mtodo de parmetro Caballo...
Como era de esperarse, cada objeto manda a llamar al mtodo que le corresponde de acuerdo a
su tipo, pero qu pasa si creamos una referencia Animal sobre un objeto Caballo...
Animal objetoAnimalRefCaballo = new Caballo();
as.MetodoSobrecargado(objetoAnimalRefCaballo);
El resultado es:
Mtodo de parmetro Animal...
Aunque en tiempo de ejecucin el objeto es un Caballo y no un Animal, la eleccin de qu mtodo
sobrecargado invocar no se realiza dinmicamente en tiempo de ejecucin, el tipo de referencia, no
el objeto actual, es el que determina qu mtodo es el que se ejecutar.
Reglas de la sobrecarga y sobreescritura de mtodos::
Ahora que hemos visto ambas formas de reescribir mtodos, revisemos las reglas y diferencias
entre ambos tipos de reescritura:

+Argumentos: En un mtodo sobrecargado los argumentos deben de cambiar mientras que en un

mtodo sobreescrito NO deben cambiar.
+ El tipo de retorno: En un mtodo sobrecargado el tipo de retorno puede cambiar, en un mtodo
sobreescrito NO puede cambiar, excepto por subtipos del tipo declarado originalmente.
+ Excepciones: En un mtodo sobrecargado las excepciones pueden cambiar, en un mtodo
sobreescrito pueden reducirse o eliminarse pero NO deben de arrojarse excepciones nuevas o ms
amplias.
+ Acceso: En un mtodo sobrecargado puede cambiar, en un mtodo sobreescrito el acceso NO
debe de hacerse ms restrictivo(puede ser menos restrictivo).
+ Al invocar: En un mtodo sobrecargado los argumentos son los que determinan qu mtodo es
el que se invocar, en un mtodo sobreescrito el tipo de objeto determina qu mtodo es elegido.

Constructores
Cuando se construye un objeto es necesario inicializar sus variables con valores coherentes,
imaginemos un objeto de la clase Persona cuyo atributo color de pelo al nacer sea verde, un
estado incorrecto tras construir el objeto persona. La solucin en los lenguajes orientados a objetos
es emplear los constructores. Un constructor es un mtodo perteneciente a la clase que posee
unas caractersticas especiales:

Se llama igual que la clase.

No devuelve nada, ni siquiera void.

Pueden existir varios, pero siguiendo las reglas de la sobrecarga de funciones.

De entre los que existan, tan slo uno se ejecutar al crear un objeto de la clase.

Dentro del cdigo de un constructor generalmente suele existir inicializaciones de variables y

objetos, para conseguir que el objeto sea creado con dichos valores iniciales.
Para definir los constructores se emplea la siguiente sintaxis:

[modifVisibilidad] nombreConstructor (listaParmetros) [throws listaExcepciones]

{
}

Para modifVisibilidad se aplica las mismas normas que para atributos y mtodos:

public: indica que es un mtodo accesible a travs de una instancia del objeto.

private: indica que a travs de una instancia no es accesible el mtodo. Al heredar el

mtodo se convierte en inaccesible.

protected: indica que a travs de una instancia no es accesible el mtodo. Al heredar si se

puede usar desde la clase derivada.

Sin especificar: indica visibilidad de paquete, se puede acceder a travs de una instancia,
pero slo de clases que se encuentren en el mismo paquete.

nombreConstructor debe de coincidir con el nombre de la clase.

listaParmetros es la lista de los parmetros que tomar la funcin separados por comas y
definidos cada uno de ellos como:

tipo nombreParmetro

La clusula opcional throws es empleada para indicar que dentro del mtodo se pueden generar
errores en su ejecucin, y que debemos estar preparados para tratarlos.
listaExcepciones es el nombre de todos esos posibles errores, su utilizacin la veremos en el punto
dedicado a la gestin de errores mediante try y catch.
El constructor posee un par de llaves, dentro de las cuales estar el cdigo que se ejecutar al ser
llamada la funcin. Dicho cdigo estar formado por instrucciones vlidas en el lenguaje,
finalizadas generalmente por punto y coma.
Prctica:

Vamos a agregar a la clase Persona un par de constructores, uno que la inicialice asignando a la edad un v
public Persona(){
edad = 0;
nombre = "annimo";
}
public Persona(String nuevoNombre){
edad = 0;
nombre = nuevoNombre;
}

y vamos a crear una clase ArranqueConstructor con el siguiente cdigo:

public class ArranqueConstructor {
public static void main (String arg[]){
Persona per1 = new Persona();
System.out.println( per1.getNombre());
System.out.println(per1.getEdad());
Persona per2 = new Persona("Luis");
System.out.println( per2.getNombre());
System.out.println(per2.getEdad());
}