TEMAS ESPECIALES DE COMPUTACIÓN LABORATORIO NÚMERO 5
La sobrecarga de
métodos consiste en crear (en una misma clase) varios métodos con la misma
firma pero con unas pequeñas diferencias:
·
La lista de argumentos (o parámetros debe ser diferente en número y/o
tipo de dato) debe ser diferente.
·
Los tipos de retorno pueden ser diferentes.
Cree la siguiente
clase Java en un archivo llamado SumaSobrecargada.java.
class
SumaSobrecargada
{
public static void main(String a[])
{
int entero_1 = 20;
int entero_2 = 86;
float float_1 = 67.23F;
float float_2 = 104.19F;
double double_1 = 35.72;
double double_2 = 98.15;
System.out.println(
suma(entero_1,entero_2) );
System.out.println(
suma(float_1,float_2) );
System.out.println( suma(double_1,double_2)
);
System.out.println( suma(double_1,float_2)
);
System.out.println( suma(a[0],a[1]) );
}
public static int suma(int a,int b)
{
return a + b;
}
public static float suma(float a,float b)
{
return a + b;
}
public static double suma(double a,double b)
{
return a + b;
}
public static double suma(String a,String b)
{
return Double.parseDouble(a) +
Double.parseDouble(b);
}
}
|
En el caso de
parámetros en los que se pueda hacer el cast implícito, Java lo hace. Por
ejemplo, en el método suma(double_1,float_2) se invoca al método public
static double suma(double a,double b), migrando el float a
double. Si se desea
hacer un paso de parámetros de un valor de tipo primitivo (o referencia de
una clase) de mayor capacidad a una de menor capacidad, se debe realizar el
cast explícito. |
Compile y ejecute
la clase. Esta ejecución va a lanzar una excepción. Trate la siguiente línea de
código System.out.println( suma(a[0],a[1]) ) para posteriormente cachar
la excepción y mandar un mensaje de que faltan parámetros desde la línea de
comandos.
También se puede
hacer sobrecarga de constructores. Cree la siguiente clase (Si ya existe
sobrescriba el código):
public
class Empleado
{
String nombre = null;
float salario = 0.0f;
public Empleado(String nom, float sal)
{
nombre = nom;
salario = sal;
}
public Empleado(String nombre)
{
this(nombre,0);
}
public Empleado()
{
this("Desconocido");
}
protected void obtenDetalle()
{
System.out.println("Empleado: " +
this.nombre + " y salario: " + this.salario);
}
public static void main(String a[])
{
Empleado emp1 = new Empleado("Daniel
Martinez",18550);
Empleado emp2 = new Empleado("Miguel
Perez");
Empleado emp3 = new Empleado();
emp1.obtenDetalle();
emp2.obtenDetalle();
emp3.obtenDetalle();
}
}
La sobreescritura
implica herencia y consiste en crear en la clase hija un método igual que se
llame igual que el de la clase padre. Aunque la nueva versión del método (en la
clase hija) si puede ser más público que la versión anterior del método (en la
clase padre).
Cree la clase en
un archivo llamado Gerente.java
public
class Gerente extends Empleado
{
String depto = "sistemas";
public Gerente(String nombre,double salario)
{
super( nombre, (float)salario );
}
public void obtenDetalle()
{
System.out.println("Empleado: " +
this.nombre + " y salario: " + this.salario + " y soy gerente
del departamento de " + this.depto);
}
public static void main(String a[])
{
Gerente g = new Gerente("Jorge
Rodriguez",45000.00);
g.obtenDetalle();
}
}
Se observa que el
nuevo método no es protected, como en la clase padre sino public pero no marca
error ya que el modificador public es más público que protected. Si la nueva
versión del método no tuviera modificador o fuera private, entonces marcaría
error. REVISAR LA TABLA DE MODIFICADORES DE ACCESO.