En PC Resumen hablaremos de que es la sobrecarga de métodos. A Java, dentro de una misma clase pueden definirse dos o más métodos con el mismo nombre, aunque la declaración de sus parámetros sea diferente. Cuando esto ocurre, se dice que los métodos están sobrecargado.
Cuando se llama a un método sobrecargado, Java utiliza el tipo y / o número de argumentos como guía para determinar qué versión del método debe ejecutar. Por lo tanto, los métodos sobrecargados deben ser diferentes en el tipo y / o en el número de parámetros. Por ejemplo:
class OverloadDemo {
void test() {
System.out.println("No parámetros");
}
// Sobrecarga el método test con un parámetro entero.
void test(int a) {
System.out.println("en: " + a);
}
// Sobrecarga el método test con dos parámetros enteros.
void test(int a, int b) {
System.out.println("a y b:" + a + "" + b);
}
// Sobrecarga el método test con un parámetro doble.
double test(double a) {
System.out.println("double a: " + a);
return a * a;
}
}
class Overload {
public static void main(String args[]) {
OverloadDemo ob = new OverloadDemo();
double Resultado;
// Llama a todas las versiones del test().
ob.test();
ob.test(10);
ob.test(10, 20);
Resultado = ob.test(123.25);
System.out.println("Resultado de ob.test(123.25): " + Resultado);
}
}La importancia de la sobrecarga radica en que permite relacionar los métodos a los que puede accederse mediante el uso de un nombre común. Cuando se sobrecarga un método, cada versión de este método puede realizar la actividad que queramos. No existe ninguna regla que establezca que los métodos sobrecargados deben relacionarse entre sí, pero desde un punto de vista de estilo, la sobrecarga implica la relación.
La sobrecarga en los constructores
Además de los métodos normales de sobrecarga, también se puede sobrecargar un método constructor. De hecho, es la situación más frecuente. Antes hemos creado un método constructor para la clase Caja, que tenía tres parámetros. Esto significa que todas las declaraciones de los objetos Caja deben pasar tres argumentos al constructor. Esto hace que si queremos una caja sin saber cuáles son las dimensiones, o en el caso de que quisiéramos inicializar un cubo especificando sólo un valor que utilizaríamos para las tres dimensiones, no lo podríamos hacer.
La solución a estos 'problemas' es muy sencilla, se trata únicamente de sobrecargar el constructor de forma que gestione estas situaciones. Por ejemplo:
class Caja {
double anchura;
double altura;
double profundidad;
// Constructor que se utiliza cuando se especifican todas las dimensiones
Caja(double w, double h, double d) {
anchura = w;
altura = h;
profundidad = d;
}
// Constructor que se utiliza cuando no se especifican dimensiones
Caja() {
anchura = -1; // Usar -1 para indicar
altura = -1; // una caja
profundidad = -1; // no inicializada.
}
// Constructor que se utiliza cuando se crea un cubo
Caja (double len) {
anchura = altura = profundidad = len;
}
// Cálculo y regreso del volumen.
double volumen () {
return ancho * altura * profundidad;
}
}