Seguimos con el ejemplo de Uso_empleado, teníamos la clase Empleado, la clase
Jefatura que hereda de la clase Empleado, si creamos otra clase a la que
llamamos Director que hereda de la clase Jefatura va a ser la más funcional
porque va a heredar de la clase Jefatura y a su vez de la clase Empleado:
Podemos crear otra
clase que esté por encima de Empleado, por ejemplo, la clase Persona:
Si utilizamos la
regla de la Herencia “Persona es un empleado”, “Un jefe es una persona”,
“Director es una persona”. Se puede crear otra clase que herede de Persona pero
que no tenga nada que ver con un Empleado, un Jefe, un Director, por ejemplo,
la clase Alumno:
Alumno es una
persona, pero no es un empleado, ni un jefe, ni un director. Sin embargo, puede
compartir métodos con estos objetos, por ejemplo, el método dameNombre(), ya que tanto el Empleado,
el Jefe, el Director y el Alumno tienen un nombre.
Pero si utilizamos
el método dameDescripcion(), ya no
es el mismo para todos, ya que el Alumno no tiene un número ID, no tiene un
sueldo, no tiene una fecha de alta de contratación. Sin embargo, podrá utilizar
este método de diferente forma, ya que no tendrá un Id pero tendrá otro tipo de
identificación, no tendrá un sueldo.. Tendrá otro tipo de información, por
ejemplo, el curso que está realizando, se le puede incluir al método las notas,
otro tipo de identificación, etc. Este método dameDescripción() lo va a heredar tanto la clase Empleado,
Jefatura, Director y el Alumno, pero en el caso del Alumno se va a utilizar de
forma diferente para ello este método en la clase Alumno debe ser declarado
como un método abstracto:
public abstract String dameDescripcion();
Al utilizar este
método como abstracto tenemos que declarar la clase Persona la que heredamos como
abstracta. Esto es una regla de Java:
abstract class Persona {…}
Vamos a verlo todo
mediante un ejemplo, nos creamos una nueva clase Uso_persona con el método
main:
package poo;
public class Uso_persona {
public static void main(String[] args) {
}
}
A esta clase le
vamos a copiar la clase Empleado cambiando el nombre de empleado por Asalariado
de forma que el código completo sea el siguiente:
package poo;
import java.util.Date;
import
java.util.GregorianCalendar;
public class Uso_persona {
public static void main(String[] args) {
// TODO
Auto-generated method stub
}
}
class Asalariado {
public
Asalariado(String nom, double sue, int agno, int mes, int dia) {
nombre = nom;
sueldo = sue;
GregorianCalendar calendario= new
GregorianCalendar(agno, mes-1, dia);
altaContrato=calendario.getTime();
}
public double dameSue() {
return sueldo;
}
public Date
dameFechaAlta() {
return altaContrato;
}
public void subeSueldo(double porcentaje) {
double aumento=sueldo*porcentaje/100;
sueldo+=aumento;
}
private double sueldo;
private Date altaContrato;
}
En el código se ha eliminado el segundo constructor y
el método dame_nombre(), la variable
de clase nombre y en el constructor
de la clase Asalariado también tenemos que eliminar la variable nombre:
nombre = nom;
Vamos a crear la clase Persona con su
constructor y la variable nombre:
class Persona {
public Persona(String nom){
nombre=nom;
}
private String nombre;
}
Creamos el método Getter
para que nos devuelva el nombre:
public String
dameNombre() {
return nombre;
}
La clase Persona va a tener además de este método el
método dameDescripcion este método
lo vamos a declarar como abstracto:
public abstract String dameDescripcion();
A la misma vez que declaramos el método
como abstracto tenemos que declarar la clase como abstracta.
abstract class Persona
{
De esta manera todas las clases que hereden de la
clase Persona tendrán que sobrescribir el método dameDescripcion.
Una vez hecho todo esto la clase Asalariado va a
heredar de la clase Persona y en el constructor hay que llamar al constructor
padre de la clase Persona.
class Asalariado
extends Persona{
public
Asalariado(String nom, double sue, int agno, int mes, int dia) {
super(nom);
sueldo=sue;
GregorianCalendar calendario=new
GregorianCalendar (agno, mes-1, dia);
altacontrato=calendario.getTime();
}
Una vez hecho esto tenemos que crear el método dameDescripción:
public String dameDescripcion()
{
return "Este
empleado tiene un sueldo de: "+sueldo;
}
Creamos ahora una segunda clase, la clase Alumno:
class Alumno extends Persona{
public Alumno(String nom, String car) {
super(nom);
carrera=car;
}
private String carrera;
}
Dentro de esta clase creamos el método dameDescripción:
public String
dameDescripcion() {
return "El
alumno está cursando la carrera de: "+carrera;
}
Vamos al método main para crear los objetos:
Persona[]
lasPersonas=new Persona[2];
lasPersonas[0]=new Asalariado("Luis Conde", 50000, 2009,
10, 05);
lasPersonas[1]=new Alumno("Paco
Martinez", "Empresariales");
for(Persona p: lasPersonas) {
System.out.println(p.dameNombre()+" ,
"+p.dameDescripcion());
}
}
Si ejecutamos la aplicación:
2.14 REFUNDICIÓN DE OBJETOS (CASTING) << >> 2.16 MODIFICADORES DE ACCESO
No hay comentarios:
Publicar un comentario