Hola a todos, hoy os explicare en que consiste la herencia en Java, es algo que debemos tener claro, para conseguir un máximo provecho a las clases y objetos.
La herencia en Java consiste en la creación de clases a partir de otras ya existentes. Tenemos lo que llamamos una clase padre (superclase) y clases hijas (clases derivadas), que heredan los métodos y atributos de su clase padre.
Vamos a ver un ejemplo, tenemos una clase empleado que sera una superclase y las clases hijas serán el tipo de empleados que puede haber como comerciales o repartidores.
La idea es que los empleados sean del tipo que sean tienen atributos o métodos comunes y para optimizar las clases creamos una clase padre que contenga todo lo común a todas las hijas y en las hijas, ademas de los atributos del padre pueden tener sus propios atributos o métodos.
Una buena forma de ver la herencia, es con la frase «es un». Por ejemplo, un Comercial «es un» Empleado o un Repartidor «es un» Empleado.
Ahora lo vemos de forma practica:
–Clase padre Empleado
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 |
/** * Clase Empleado * * Contiene informacion de cada empleado * * @author Fernando * @version 1.0 */ public class Empleado { //Atributos /** * Nombre del empleado */ protected String nombre; /** * Apellido del empleado */ protected String apellido; /** * Edad del empleado */ protected int edad; /** * Salario del empleado */ protected double salario; //Metodos publicos /** * Devuelve el nombre del empleado * @return nombre del empleado */ public String getNombre() { return nombre; } /** * Modifica el nombre de un empleado * @param nombre */ public void setNombre(String nombre) { this.nombre = nombre; } /** * Devuelve la edad de un empleado * @return edad del empleado */ public int getEdad() { return edad; } /** * Modifica la edad de un empleado * @param edad */ public void setEdad(int edad) { this.edad = edad; } /** * Devuelve el salario de un empleado * @return salario del empleado */ public double getSalario() { return salario; } /** * Suma un plus al salario del empleado si el empleado tiene mas de 40 años * @param sueldoPlus * @return * * * */ public boolean plus (double sueldoPlus){ boolean aumento=false; if (edad>40 && compruebaNombre()){ salario+=sueldoPlus; aumento=true; } return aumento; } //Metodos privados /** * Comprueba que el nombre no este vacio * @return * * * */ private boolean compruebaNombre(){ if(nombre.equals("")){ return false; } return true; } //Constructores /** * Constructor por defecto */ public Empleado(){ this ("", "", 0, 0); } /** * Constructor con 4 parametros * @param nombre nombre del empleado * @param apellido nombre del empleado * @param edad edad del empleado * @param salario salario del empleado */ public Empleado(String nombre, String apellido, int edad, double salario){ this.nombre=nombre; this.apellido=apellido; this.edad=edad; this.salario=salario; } } |
–Clase hija Comercial
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
/** * Clase Comercial * * Contiene información de un comercial, un tipo de empleado * * @author Fernando * @version 1.0 */ public class Comercial extends Empleado{ //Atributos, aunque no indiquemos nada es como si tuviera los atributos del padre /** * Comision por venta del comercial */ private double comision; /** * Constructor por defecto */ public Comercial(){ this.comision=0; } /** * Constructor con 5 parametros * @param nombre nombre del comercial * @param apellido apellido del comercial * @param edad edad del comercial * @param salario salario del comercial * @param comision comision del comercial */ public Comercial(String nombre, String apellido, int edad, double salario, double comision) { super(nombre, apellido, edad, salario); this.comision=comision; } } |
–Clase hija Repartidor
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
/** * Clase Repartidor * * Contiene información de un repartidor, un tipo de empleado * * @author Fernando * @version 1.0 */ public class Repartidor extends Empleado{ //Atributos, aunque no indiquemos nada es como si tuviera los atributos del padre /** * Zona del repartidor */ private String zona; /** * Constructor por defecto */ public Repartidor(){ this.zona=""; } /** * Constructor con 5 parametros * @param nombre nombre del repartidor * @param apellido apellido del repartidor * @param edad edad del repartidor * @param salario salario del repartidor * @param zona zona del repartidor */ public Repartidor(String nombre, String apellido, int edad, double salario, String zona) { super(nombre, apellido, edad, salario); this.zona=zona; } } |
Vayamos por partes, en la clase padre, vemos que los atributos en lugar de private usamos protected, haciendo que los atributos se hereden a las clases hijas.
En las clases hijas, vemos que después del nombre de la clase escribimos extends nombre_clase_padre, también tienen sus propios atributos.
Debemos tener en cuenta varios aspectos, los constructores de la clase hija siempre llaman al constructor por defecto (el que no tiene parámetros) de la clase padre, también podemos indicar que constructor debe de llamar, se indica con super(parametros);, después podemos hacer lo queramos. Si no indicamos nada es como si escribiéramos super();.
También debemos tener en cuenta que los métodos no es necesario que los heredemos, ya que con public las clases hijas podrán acceder a los métodos de la clase padre.
También podemos llamar métodos de la clase padre con super.nombre_método(parámetros) podemos usarlo para que llame a un método que necesitamos para un método de la clase hija. Nos ahorrara trabajo, es mejor que copiar y pegar código.
Ahora vamos a ver un ejemplo de crear objetos de estas clases heredadas:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
public class EmpleadoApp { public static void main(String[] args) { //Creamos objetos de las clases hijas Comercial comercial1=new Comercial("Antonio", "Lopez", 24, 600, 50); Repartidor repartidor1=new Repartidor("Fernando", "Ureña", 43, 400, "Este"); //Invocamos los metodos de la clase padre comercial1.plus(300); repartidor1.plus(300); //Mostramos los atributos, usando los metodos get de la clase padre System.out.println("El salario actual del comercial es "+comercial1.getSalario()); System.out.println("El salario actual del repartidor es "+repartidor1.getSalario()); } } |
Por último, recuerda que que la herencia va de arriba a abajo, es decir, que una clase padre no podrá acceder la clase hija pero si al revés. Ademas solo podemos heredar una sola clase.
Espero que os sea de ayuda. Si tenéis dudas, preguntad. Estamos para ayudarte.
Las dudas nuevamente son muchas y variadas jejej. Interesante Post
TRAFFIC CLUB, Fútbol y Tenis, más que un juego
entiendo mas bien poco de informatica , pero tu blog tiene pinta de ayudar mucho a la gente con pocos conociemientos .. enhorabuena traffic club 3 – INFOmeteoMCL METEOBLOG
Hola muy buena explicación pero los constructores por defecto dan error, sabes a que se debe?
hola tenia dos años sin usar java y ahora que ya trabajo tu web me ha ayudado a sacar el polvo y recordar el manejo de java la verdad te mereces un reconocimiento ya que has armado aqui una pequeña wikipedia :) DDR !!!
Según lo que leído sólo puede haber una clase padre y varias clases hijas, ¿no?.