Mediante la Herencia es posible crear una clase a partir de otra clase padre, la cual herederá tanto sus propiedades o atributos como los métodos de la misma
Se puede usar la herencia cuando una Clase hijo puede aprovechar toda o parte de la funcionalidad de la Clase padre, sin que llegue a resultar en algo conceptualmente muy distinto de ella.
La herencia permite la sobrescritura de métodos definidos en la clase padre en las clases que hereden de ella, pudiendo así comportarse de forma diferente. En caso necesario es posible procesar también el método de la clase padre utilizando super (en el siguiente ejemplo mostramos cómo).
En lenguaje Java se indica anteponiendo @Override a la definición del método.
Por ejemplo, podríamos crear una clase llamada Persona que contenga las propiedades comunes a todas (nombre, apellidos, color de pelo y ojos, etc.) y métodos que identifiquen las acciones que realizan (hablar, caminar, saludar...), y luego otras que hereden de ella llamadas Usuario y Profesor.
Algunos lenguajes de Programación Orientados a Objetos (como C++) soportan herencia múltiple, mediante la que se hace posible el crear una clase que herede de una o más Clases).
En otros lenguajes de programación que no la soportan (como Java) se puede simular mediante la implementación de Interfaces.
Veamos un ejemplo en lenguaje Java.
Main.java:
package EjemplosPOO.ejemplo02;
public class Main
{
public static void main(String[] args)
{
// Creamos un objeto Toyota de tipo
Toyota c = new Toyota();
// Ahora damos un valor a dicha propiedad pero usando el método heredado de Coche
c.setMarchas( 5 );
// Llamamos al método propio de Toyota
c.setModelo("COROLLA");
// Mostramos los datos del coche
System.out.println("Coche Toyota modelo [" + c.getModelo() + "] con [" + c.getMarchas() + "] marchas");
// Probamos el método sobreescrito
c.arrancar();
}
}
Coche.java:
package EjemplosPOO.ejemplo02;
public class Coche
{
// ---------------------------- PROPIEDADES O ATRIBUTOS
private int marchas;
// ---------------------------- CONSTRUCTOR
public Coche() {
}
// ---------------------------- MÉTODOS
public int getMarchas() {
return this.marchas;
}
// ----------------------------
public void setMarchas(int marchas) {
this.marchas = marchas;
}
// ----------------------------
public void arrancar() {
System.out.println("Comprobando el sistema de encendido...");
}
}
Toyota.java (hereda de Coche indicándolo con extends):
package EjemplosPOO.ejemplo02;
public class Toyota extends Coche
{
private String modelo;
// ----------------------------
public Toyota(){
}
// ----------------------------
public String getModelo() {
return this.modelo;
}
// ----------------------------
public void setModelo( String modelo ) {
this.modelo = modelo;
}
// ----------------------------
// Este método está sobreescrito
@Override
public void arrancar()
{
// Utilizamos 'super' para procesar el método 'arrancar()' de la clase padre
super.arrancar();
// A continuación procesamos otro código específico
System.out.println("El Toyota está en marcha");
}
}
Al ejecutar el programa veríamos lo siguiente:
Vea también: [ Herencia ] - [ Polimorfismo ]
