La herencia en
programación es como la vida real. Imaginaros que nuestros abuelos tienen una
casa y un coche, el día de mañana la casa y el coche lo heredarán nuestros
padres, de forma que a lo largo de la vida nuestros padres comprarán otra casa,
otro coche y una moto, de forma que tendrán lo que ellos han heredado de
nuestros abuelos y lo que han adquirido durante su vida. Nosotros heredaremos
la casa y el coche de los abuelos, la casa, el coche y la moto de nuestros
padres y a la vez tendremos que lo que adquiramos a lo largo de nuestra vida.
Más o menos esto sería el concepto de herencia.
Con el ejemplo del
Coche, tiene una serie de propiedades y de métodos pero hemos de crear otro
objeto que se asemeje al Coche, por ejemplo, una furgoneta. La furgoneta no es
un coche pero tiene propiedades y métodos comunes al coche además de tener sus
propias propiedades como la capacidad de carga o el número de plazas. Para
verlo más claro lo vemos mediante un ejemplo, nos vamos a crear una clase a la
que vamos a llamar Furgoneta sin el
método main que va a heredar de la clase Coche.
package poo;
public class Furgoneta extends Coche{
}
Para indicarle que
esta clase hereda de la clase Coche utilizamos la palabra extends. Esto significa que Furgoneta va a heredar las propiedades,
el método y el constructor. Sin embargo, como hemos comentado la Furgoneta
tiene una serie de propiedades propias como la carga o el número de plazas:
package poo;
public class Furgoneta extends Coche{
private int capacidad_carga;
private int plazas_extra;
}
Y tiene su propio
constructor:
package poo;
public class Furgoneta extends Coche{
private int capacidad_carga;
private int plazas_extra;
public Furgoneta(int capacidad_carga, int plazas_extra) {
super();
}
}
Utilizamos la
palabra super() para llamar al
constructor de la clase padre, Coche. Inicializamos las propiedades de la clase
Furgoneta:
package poo;
public class Furgoneta extends Coche{
private int capacidad_carga;
private int plazas_extra;
public Furgoneta(int capacidad_carga, int plazas_extra) {
super();
this.capacidad_carga = capacidad_carga;
this.plazas_extra = plazas_extra;
}
}
Creamos un método
para que nos dé la información de las propiedades de la furgoneta:
public String
dameDatosFurgoneta() {
return "La capacidad de carga es: "+capacidad_carga+" y las plazas extran son: "+plazas_extra;
}
Si nos vamos a la
clase Uso_vehiculos que es la que
contiene el método main y es la que se ejecuta, vamos eliminar todo lo que hay
en ella y vamos a crearnos un objeto de tipo Coche y otro de tipo Furgoneta:
public static void main(String[] args) {
Coche coche1 = new Coche();
Furgoneta furgoneta1 = new Furgoneta(580, 7);
}
A la furgoneta le
hemos pasado por parámetros la capacidad de carga y las plazas.
Vamos a llamar al
método establece_color() para dar un
color al coche y a la furgoneta:
public static void main(String[] args) {
Coche coche1 = new Coche();
Furgoneta furgoneta1 = new Furgoneta(580, 7);
coche1.establece_color("Rojo");
furgoneta1.establece_color("Azul");
}
Como podemos
observar la furgoneta hereda este método. Mediante un System.out imprimimos el método:
public static void main(String[] args) {
Coche coche1 = new Coche();
Furgoneta furgoneta1 = new Furgoneta(580, 7);
coche1.establece_color("Rojo");
furgoneta1.establece_color("Azul");
System.out.println(coche1.dame_color());
System.out.println(furgoneta1.dame_color());
}
}
Si vemos el
resultado:
En el método dame_color() de la clase coche podemos
modificar la frase: “El color del coche..”
por “El color del vehículo…” así más
generalizado.
Podemos indicar al
objeto furgoneta si tiene climatizador o asientos de cuero:
public static void main(String[] args) {
Coche coche1 = new Coche();
Furgoneta furgoneta1 = new Furgoneta(580, 7);
coche1.establece_color("Rojo");
furgoneta1.establece_color("Azul");
furgoneta1.configura_climatizador("si");
furgoneta1.establece_asientos_cuero("si");
}
Mediante un System.out vamos a indicarle que nos de
los datos generales y los datos específicos de la furgoneta:
public static void main(String[] args) {
Coche coche1 = new Coche();
Furgoneta furgoneta1 = new Furgoneta(580, 7);
coche1.establece_color("Rojo");
furgoneta1.establece_color("Azul");
furgoneta1.configura_climatizador("si");
furgoneta1.establece_asientos_cuero("si");
System.out.println(coche1.dame_datos_generales()+" "+coche1.dame_color());
System.out.println(furgoneta1.dameDatosFurgoneta()+". "+furgoneta1.dame_color());
}
Si probamos:
Para entender mejor
la herencia hay que tener en cuenta la regla “Es un..”. Por ejemplo, en el caso del coche y la furgoneta ambos
tienen en común que son vehículos. El coche es un vehículo. La furgoneta es un
vehículo. Una moto o un camión también serían vehículos, comparten todos ellos
unas características y métodos comunes.
Vamos a ver la
forma de diseñar la herencia. Teníamos la clase Empleado:
class Empleado {
public Empleado(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 Empleado(String
nom) {
this(nom, 30000, 2002,
01, 01);
}
public String
dameNombre() {
return nombre;
}
public double dameSue() {
return sueldo;
}
public Date
dameFechaAlta() {
return altacontrato;
}
public void subeSueldo(double porcentaje) {
double aumento = sueldo * porcentaje/100;
sueldo+=aumento;
}
private String nombre;
private double sueldo;
private Date altacontrato;
}
Lo que queremos es
crear otra clase relacionada con Jefes,
los Jefes además de recibir un sueldo van a tener un incentivo. ¿Sirve la clase Empleado para crear la clase
Jefes? Aquí hay que emplear la regla “Es
un…” El jefe es un empleado: sí. Un empleado es un jefe: sí. Por lo que sí
que se puede crear una clase siendo la clase Empleado la clase padre y la clase
Jefe, la clase hijo.
Por lo que a
continuación de la clase Empleado vamos a crear una clase a la que vamos a
llamar Jefatura que va a heredar de la clase Empleado:
class Jefatura
extends Empleado {
}
Esta clase va a
tener su propio constructor:
class Jefatura extends Empleado {
public Jefatura(String
nom, double sue, int agno, int mes, int dia) {
}
}
Dentro de este
constructor vamos a llamar al constructor de la clase padre, la clase Empleado
esto se hacía con la palabra super():
public Jefatura(String
nom, double sue, int agno, int mes, int dia) {
super(nom, sue, agno, mes, dia);
}
Lo primero que
vamos a hacer es crearnos una variable que sea el incentivo:
class Jefatura extends Empleado {
public Jefatura(String
nom, double sue, int agno, int mes, int dia) {
super(nom, sue, agno, mes, dia);
}
private double incentivo;
}
Posteriormente un
método Setter que nos devuelva el
incentivo:
class Jefatura extends Empleado {
public Jefatura(String
nom, double sue, int agno, int mes, int dia) {
super(nom, sue, agno, mes, dia);
}
public void estableceIncentivo(double b) {
incentivo=b;
}
private double incentivo;
}
Luego un método Getter que nos devuelva el sueldo, como
en la clase Empleado ya hay una clase damesueldo()
lo que vamos a hacer es sobrescribirlo:
class Jefatura extends Empleado {
public Jefatura(String
nom, double sue, int agno, int mes, int dia) {
super(nom, sue, agno, mes, dia);
}
public void
estableceIncentivo(double b) {
incentivo=b;
}
public double dameSue() {
double sueldoJefe=super.dameSue();
return sueldoJefe + incentivo;
}
private double incentivo;
}
Para crear la
instancia de la clase Jefatura en el método main vamos a ver un nuevo concepto
que es el Polimorfismo en el siguiente post.
2.11 SOBRECARGA DE CONSTRUCTORES << >> 2.13 POLIMORFISMO
No hay comentarios:
Publicar un comentario