Un método sobrecargado se utiliza para reutilizar el nombre de un método pero con diferentes argumentos (opcionalmente un tipo diferente de retorno). Las reglas para sobrecargar un método son las siguientes:
- Los métodos sobrecargados debe de cambiar la lista de argumentos.
- Pueden cambiar el tipo de retorno.
- Pueden cambiar el modificador de acceso.
- Pueden declarar nuevas o más amplias excepciones.
- Un método puede ser sobrecargado en la misma clase o en una subclase.
Veamos un método que se desea sobrecargar:
public void cambiarTamano(int tamano, String nombre, float patron){ }
Los siguientes métodos son sobrecargas legales del método cambiarTamano():
public void cambiarTamano(int tamano, String nombre){}
public int cambiarTamano(int tamano, float patron){}
public void cambiarTamano(float patron, String nombre) throws IOException{}
Cómo invocar un método sobrecargado
Lo que define qué método es el que se va a llamar son los argumentos que se envían al mismo durante la llamada. Si se invoca a un método con un String como argumento, se ejecutará el método que tome un String como argumento, si se manda a llamar al mismo método pero con un float como argumento, se ejecutará el método que tome un float como argumento y así sucesivamente. Si se invoca a un método 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 método sobrecargado:
public class Sobrecarga {
public void Numeros(int x, int y){
System.out.println("Método que recibe enteros.");
}
public void Numeros(double x, double y){
System.out.println("Método que recibe flotantes.");
}
public void Numeros(String cadena){
System.out.println("Método 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 código anterior obtendremos lo siguiente:
Método que recibe enteros.
Método que recibe flotantes.
Método que recibe una cadena
Al utilizar objetos en lugar de tipos primitivos o cadenas se vuelve más interesante. Veamos lo que sucede cuando se tiene un método sobrecargado que en una de sus versiones toma un Animal como parámetro y en otra un Caballo.
class Animal { }
class Caballo extends Animal{ }
class Animales{
public void MetodoSobrecargado(Animal a){
System.out.println("Método de parámetro Animal...");
}
public void MetodoSobrecargado(Caballo c){
System.out.println("Método de parámetro 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 código anterior obtenemos:
Método de parámetro Animal...
Método de parámetro Caballo...
Como era de esperarse, cada objeto manda a llamar al método 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:
Método de parámetro Animal...
Aunque en tiempo de ejecución el objeto es un Caballo y no un Animal, la elección de qué método sobrecargado invocar no se realiza dinámicamente en tiempo de ejecución, el tipo de referencia, no el objeto actual, es el que determina qué método es el que se ejecutará.
Reglas de la sobrecarga y sobreescritura de métodos
Ahora que hemos visto ambas formas de reescribir métodos, revisemos las reglas y diferencias entre ambos tipos de reescritura:
- Argumentos: En un método sobrecargado los argumentos deben de cambiar mientras que en un método sobreescrito NO deben cambiar.
- El tipo de retorno: En un método sobrecargado el tipo de retorno puede cambiar, en un método sobreescrito NO puede cambiar, excepto por subtipos del tipo declarado originalmente.
- Excepciones: En un método sobrecargado las excepciones pueden cambiar, en un método sobreescrito pueden reducirse o eliminarse pero NO deben de arrojarse excepciones nuevas o más amplias.
- Acceso: En un método sobrecargado puede cambiar, en un método sobreescrito el acceso NO debe de hacerse más restrictivo(puede ser menos restrictivo).
- Al invocar: En un método sobrecargado los argumentos son los que determinan qué método es el que se invocará, en un método sobreescrito el tipo de objeto determina qué método es elegido.
Esto es todo con la sobrecarga de métodos en Java. ¿Alguna duda? dejen sus comentario.
