… y relaciones incestuosas.
Ya he hecho mención anteriormente al tema de la herencia. La idea era que, teniendo una clase determinada hacemos otra derivada de esta. Como que es un derivado de esta en la jerga oficial de java se dice que hereda de esta. Como en el siguiente ejemplo.
// PonerMesa.java
class Plato{
Plato(int i){
System.out.println("constructor de plato");
}
}
class PlatoCena extends Plato{
PlatoCena(int i){
super(i); // esto llama al constructor de plato
System.out.println("de cenar");
}
}
class Utensilio{
Utensilio(int i){
System.out.println("haciendo un utensilio");
}
}
class Cuchara extends Utensilio{
Cuchara(int i){
super(i);
System.out.println("una cuchara");
}
}
class Tenedor extends Utensilio{
Tenedor(int i){
super(i);
System.out.println("un tenedor");
}
}
public class PonerMesa{
Cuchara cc;
Tenedor tn;
PlatoCena pc;
PonerMesa(int i){
cc = new Cuchara(i+4);
tn = new Tenedor(i+4);
pc = new PlatoCena(i+4);
System.out.println("poniendo la mesa");
}
public static void main(String[] args){
int cantidad = 0;
try{
cantidad = Integer.parseInt(args[0]);
}catch (ArrayIndexOutOfBoundsException e){
System.out.println("debes especificar un numero de mesas");
}catch(NumberFormatException e2){
System.out.println("debes especificar un NUMERO de mesas");
}
if (cantidad == 0){
System.out.println("debes pasar un número de mesas");
}
else{
PonerMesa x = new PonerMesa(2);
}
}
}
Pero pasa que el ejemplo es demasiado simple y peca por defecto. Sirve para captar la noción de la idea de herencia. Pero para que captes la idea, escribas un código mucho mas elegante, útil y potente hechale un ojo a este otro ejemplo:
//Detergente.java
// sintaxis y porpiedades de la herencia
// clase madre
class ProductoLimpieza{
private String s = new String("Producto de limpieza");
public void anidar(String a){ s += a; }
public void diluir(){ anidar(" diluir() ");}
public void aplicar(){ anidar(" aplicar() ");}
public void fregar(){ anidar(" fregar() ");}
protected void escurrir(){ anidar(" escurrir() ");}
public void escribir(){ System.out.println(s);}
public static void main(String[] args){
ProductoLimpieza x = new ProductoLimpieza();
x.diluir();
x.aplicar();
x.fregar();
x.escurrir();
x.escribir();
}
}
// clase hija
public class Detergente extends ProductoLimpieza{
// cambiamos un método
public void fregar(){
anidar(" Deterngente.frotar() "); // introducimos los cambios
super.fregar(); // y llamamos al método de la clase madre
}
public void aclarar(){ anidar(" aclarar() ");}
public static void main(String[] args){
Detergente x = new Detergente();
x.diluir();
x.aplicar();
x.fregar();
x.aclarar();
x.escurrir();
x.escribir();
System.out.println("probando la clase base");
ProductoLimpieza.main(args);
}
}
Aquí ves (casi) todo lo que puedes hacer con la herencia y te das cuenta de todas sus posibilidades. Por un lado la clase base no es una clase coja. Es una clase que puede funcionar por si misma y que funciona por si sola. Si haces java ProductoLimpieza verás que funciona sola y aisladamente. Por otro lado ves que se pueden reescribir métodos, completa o parcialmente. Y tambien el funcionamiento de los métodos protegidos. Al método escurrir no se puede acceder desde el exteriror. Sólo desde las hijas de ProductoLimpieza y de los integrantes de su paquete, que en este caso no es ninguno.