Java permite declarar métodos con el mismo nombre en la misma clase, siempre y cuando tengan distintos conjuntos de parámetros (determinados en base al número, tipos y orden de los parámetros). A esto se le conoce como sobrecarga de métodos. Cuando se hace una llamada a un método sobrecargado, el compilador de Java selecciona el método apropiado mediante un análisis del número, tipos y orden de los parámetros en la llamada. Por lo general, la sobrecarga de métodos se utiliza para crear varios métodos con el mismo nombre que realicen la misma tarea o tareas similares, pero con distintos tipos o distintos números de parámetros.
Ejemplo
public class SobrecargaMetodos {
public static int cuadrado(int numero){
return numero*numero;
}
public static float cuadrado(float numero){
return numero*numero;
}
public static double cuadrado(double numero){
return numero*numero;
}
public static void main(String[] args) {
int x=4;
float y=3.5f;
double z=13;
System.out.println(«El cuadrado de «+x+» es: » + cuadrado(x));
System.out.println(«El cuadrado de «+y+» es: » + cuadrado(y));
System.out.println(«El cuadrado de «+z+» es: » + cuadrado(z));
}
}
¿Cómo se diferencian los métodos sobrecargados entre sí?
El compilador diferencia los métodos sobrecargados en base a su firma: una combinación del nombre del método y del número, tipos y orden de sus parámetros. Si el compilador sólo se fijara en los nombres de los métodos durante la compilación. De manera interna, el compilador utiliza nombres de métodos más largos que incluyen el nombre del método original, el tipo de cada parámetro y el orden exacto de los parámetros para determinar si los métodos en una clase son únicos en esa clase.
Por ejemplo, en el ejemplo anterior el compilador podría utilizar el nombre lógico «cuadrado de int» para el método cuadrado que especifica un parámetro int, y el método «cuadrado de double» para el método cuadrado que especifica un parámetro double (los nombres reales que utiliza el compilador son más complicados).
Si la declaración de método1 empieza así:
void metodo1(int a, float b)
entonces el compilador podría usar el nombre lógico «método1 de int y float». Si los parámetros se especificaran así:
void metodo1(float a, int b)
entonces el compilador podría usar el nombre lógico «método1 de float e int». Observe que el orden de los tipos de los parámetros es importante; el compilador considera que los dos encabezados anteriores de método1 son distintos.
Tipos de valores de retorno de los métodos sobrecargados
Al hablar sobre los nombres lógicos de los métodos que utiliza el compilador, no mencionamos los tipos de valores de retorno de los métodos. Esto se debe a que las llamadas a los métodos no pueden diferenciarse en base al tipo de valor de retorno. El programa del ejemplo ilustra los errores que genera el compilador cuando dos métodos tienen la misma firma, pero distintos tipos de valores de retorno. Los métodos sobrecargados pueden tener tipos de valor de retorno diferentes si los métodos tienen distintas listas de parámetros. Además, los métodos sobrecargados no necesitan tener el mismo número de parámetros.
Ejemplo
public class ErrorSobrecargaMetodos {
// declaración del método cuadrado con argumento int
public int cuadrado(int x){
return x*x;
}
// la segunda declaración del método cuadrado con
// con argumento int produce un error de compilación,
// aun cuando los tipos de valores de retorno son distintos
public double cuadrado(int y){
return y*y;
}
}
Salida – ErrorSobrecargaMetodos (run)
run:
java.lang.ExceptionInInitializerError
Caused by: java.lang.RuntimeException: Uncompilable source code – method cuadrado(int) is already defined in class prueba.ErrorSobrecargaMetodos
Nota
- Las declaraciones de métodos sobrecargados con firmas idénticas producen errores de compilación, aun si los tipos de valores de retorno son distintos.
- Declarar métodos sobrecargados con listas de parámetros idénticas es un error de compilación, sin importar que los tipos de los valores de retorno sean distintos.