Herencia

Cuando hablamos de la programación orientada a objetos es inevitable tratar con el tema de la Herencia, ya que es una de la principales características de este enfoque. La herencia es una característica que nos permite la creación de clases (subclase) a partir de una clase ya creada (superclase); de modo que cuando estemos creando una clase y decidimos que va a heredar de otra clase ya existente, lo la clase que estamos creando podrá hacer uno de los métodos y atributos de la clase que ya existe (de la cual heredamos).

Ejemplo:

Creamos una clase Persona y una clase Estudiante, distintas una de la otra:

Bien estas son dos diferentes clases por separado, independientes.

Pero pensemos que un estudiante también tiene los mismos atributos y los mismos métodos que una persona, pero una persona no necesita los mismos atributos y métodos que un estudiante. Entonces pensemos en que la clase estudiante puede heredar los métodos y atributos de la clase Persona, de tal modo que podríamos visualizar algo más o menos así:

La clase Estudiante HEREDA de la clase Persona:

El ejemplo anterior es una analogía con personas (un caso cotidiano) para dejar en claro la esencia de la Herencia. Ahora procederé a mostrarles un código de como se maneja la herencia en Java:

/**
 *Archivo: Persona.java
 * @author Anibal Clavel
 * http://www.buenasintencions.blogspot.mx
 */

public class Persona {
    
    //Declaracion de atributos:
    String nombre;
    int edad;
    
    //Constructor:
    public Persona(){
        
    }
    
    //Metodo dormir:
    public String domir(){
        return "zZzzZ";
    }
    
    //Metodo comer:
    public String comer(){
        return "comiendo...";
    }
    
    //Setters y Getters.
    public void setNombre(String n){
        nombre = n;
    }
    
    public void setEdad(int e){
        edad = e;
    }
    
    public String getNombre(){
        return nombre;
    }
    
    public int getEdad(){
        return edad;
    }
}// fin de la clase Persona.

Creada la clase Persona con sus respectivos métodos, atributos, setters y getters. Esto como siempre hemos planteado la clase Persona, y debido a que es simple de entender, solo voy a decirles que a partir de esta clase vamos a crea una clase nueva, la clase Estudiante. La clase Estudiante va a ser hija (va a heredar) de la clase Persona, por lo tanto un objeto de la clase Estudiante podrá hacer uso de los métodos de la clase Persona también.

Ahora el código de la clase Estudiante, con sus métodos y atributos propios y con una linea de código donde indicamos que hereda de otra clase:

/**
 *Archivo: Estudiante.java
 * @author Anibal Clavel
 * http://www.buenasintencions.blogspot.mx
 */

public class Estudiante extends Persona{
    
    //Declaracion de atributos:
    String carrera, matricula;
    
    //Metodo estudiar:
    public String estudiar(String materia){
        return "estudiando... "+materia;
    }
    
    //Metodo hacer examen:
    public String hacerExamen(){
        return "haciendo exmane";
    }
    
    //Setters y Getters
    public void setCarrera(String c){
        carrera = c;
    }
    
    public void setMatricula(String m){
        matricula = m;
    }
    
    public String getCarrera(){
        return carrera;
    }
    
    public String getMatricula(){
        return matricula;
    }
}//fin de la clase Estudiante.

Como ven la creación de esta clase es de la forma tradicional que siempre lo hacemos, a excepción de que en la linea 7 al momento de definir la clase Estudiante, mediante la palabra reservada extends le indicamos que esa clase va a heredar de otra clase, en este caso de Persona.

Para este momento ya tenemos creadas 2 clases diferentes, Persona y Estudiante (que hereda de la primera), creare una clase principal para hacer objetos de la clase estudiante y probar nuestra herencia:

/**
 *Archivo: Prueba.java
 * @author Anibal Clavel
 * http://www.buenasintencions.blogspot.mx
 */

import javax.swing.JOptionPane;

public class Prueba{
    
    public static void main(String args[]){
        
        String dato1;
        int dato2;
        Estudiante e = new Estudiante();
        
        dato1=JOptionPane.showInputDialog("Nombre:");
        e.setNombre(dato1);
        dato2=Integer.parseInt(JOptionPane.showInputDialog("Edad:"));
        e.setEdad(dato2);
        dato1=JOptionPane.showInputDialog("Carrera:");
        e.setCarrera(dato1);
        dato1=JOptionPane.showInputDialog("Matricula:");
        e.setMatricula(dato1);
        
        System.out.println("El nombre de la persona es:");
        System.out.println(e.getNombre());
        System.out.println("\n...y su edad es: "+e.getEdad());
        System.out.println("Estudia: "+e.getCarrera());
        System.out.println("con matricula: "+e.getMatricula());
        
        System.out.println("Tiene la capacidad de hacer estos metodos:");
        System.out.println(e.domir());
        System.out.println(e.comer());
        System.out.println(e.estudiar("Matematicas"));
        System.out.println(e.hacerExamen());
    }
}

Bien, en esta clase principal se crea un objeto e de la clase Estudiante y se hace uso de sus métodos, y también se hace uso de los métodos de la clase Persona ya que puede utilizarlos.

De este modo es como funciona la herencia en la programación orientada a objetos en Java, permite que clases hijas puedan usar los métodos o atributos de clases padres, ahora podemos correr nuestro programa y observar los resultados obtenidos para un mejor entendimiento del tema y para probar como es que realmente ha sucedido la herencia.