HERENCIA

PROGRAMACIÓN ORIENTADA A OBJETOS

 DESARROLLO

CONCEPTO DE HERENCIA:

 Definición de Herencia:

Es uno de los conceptos más importantes de la Programación Orientada a Objetos, consiste en la

capacidad de poder heredar las características y comportamientos de una clase ya definida. Esto
significa que se puede crear una nueva clase hija a partir de una ya existente, la cual hereda los
métodos y atributos de su clase padre y además puede tener sus propios comportamientos y
características. En otras palabras la clase padre será la superclase de la nueva clase hija o también
llamada subclase; permitiendo que la subclase pueda reutilizar el código implementado en la
superclase.

Esta característica de la Programación Orientado a Objetos, ofrece al programador la capacidad de

crear subclases o clases hijas que hereden atributos y métodos comunes, definidos por una clase
mayor o padre también llamada superclase. La herencia permite definir una estructura jerárquica
entre clases.

Existen dos clases de herencia, simple y múltiple. La Herencia Simple determina un único padre
para todas aquellas subclases que se crean a partir de la clase padre. La Herencia Múltiple
determina uno o más padres para todas aquellas subclases que se crean.

 Ventajas de la Herencia:

1. Evita que el programador reescriba o duplique el código cunado implementa una aplicación.

2. Permite la reutilización del código, en este sentido las subclases pueden utilizar como propio
todo el código implementado en la superclase.

3. Facilita el mantenimiento y extensión de las aplicaciones; permitiendo agregar funcionalidad

rápidamente a las clases utilizadas con mayor frecuencia y creando nuevas clases a partir de
clases ya existentes.

4. Permite implementar el concepto de polimorfismo, a través de interfaces y clases abstractas

[1].
 Sintaxis utilizada en la implementación de herencia (Java)

Para la definir que una subclase o clase hija hereda de otra superclase, se utiliza la palabra clave
extends, por ejemplo:

public abstract class Docente extends Persona{ …. }

public class DocenteCatedra extends Docente{ …. }

En la definición anterior, se indica que la clase Docente heredara métodos y atributos de la clase
Persona. Igualmente la clase DocenteCatedra heredara de la clase Docente.

El método constructor de una subclase, invocara al método constructor de su clase padre o

superclase, para esto se utiliza la palabra clave super() seguida de paréntesis. Por ejemplo:

Superclase (Docente):

public Docente(){
super(); //La clase Docente hereda de la superclase Persona, e invoca a su constructor.
titulo = "";
correoInstitucional = "";
}

public Docente(int id, String nom, String ape, int ed, String perfil, String correo){
super(id, nom, ape, ed);
titulo = perfil;
correoInstitucional = correo;
}

Subclase (DocenteCatedra):

public DocenteCatedra(){
super(); //Docente cátedra invoca al constructor de su superclase clase Docente.
numeroHoras = 0;
categoria = "";
}

public DocenteCatedra(int id, String nom, String ape, int ed, String perfil, String correo, int nh, String cat){
//Docente cátedra invoca al constructor de su superclase clase Docente.
super(id, nom, ape, ed, perfil, correo);
numeroHoras = nh;
categoria = cat;
}
 Implementación de clases y métodos abstractos (Java)

Una clase se define como abstracta cuando se declaran dentro de ella métodos abstractos. Los
métodos abstractos no tienen cuerpo y solo pueden existir dentro de las clases abstractas. En este
sentido las clases abstractas sirven para contener los métodos abstractos y a diferencia de una clase
normal, no se podrán crear objetos a partir de una clase abstracta [2].

Como se mencionó los métodos abstractos no tienen cuerpo o implementación en la clase abstracta
en donde se declaran; y deben ser sobreescritos para ser implementados en las subclases que
hereden de la clase abstracta donde se declararon. En la declaración de métodos y clases abstractas
se utiliza la palabra clave abstract, que proviene del inglés resumen. Por ejemplo:

public abstract class Docente extends Persona{ //Declaración de la clase abstracta.

……
……
//Declaración de un método abstracto dentro de la clase abstracta.
public abstract double calcularSueldo();
}

IMPLEMENTACIÓN DEL CONCEPTO DE HERENCIA

 Ejercicio propuesto:

Para implementar el concepto de herencia imaginemos el siguiente contexto, en donde una

reconocida universidad, quiere realizar el cálculo del sueldo neto que se paga mensualmente a los
docentes de la institución. La oficina de registro tienen la información básica de cualquier docente,
como son: identificación y nombres, edad, entre otros. La universidad requiere de algún dato de
contacto para ubicar en algún momento dado a los docentes contratados, este dato puede ser el
correo electrónico institucional. Además, los profesores cuentan con un título profesional que los
acredita para dictar clase en cualquiera de los programas académicos que se ofertan dentro de la
institución universitaria.

En la universidad hay dos modalidades de contratación para los docentes; los docentes de planta o
tiempo completo y los catedráticos que trabajan por hora cátedra. El sueldo de los profesores de
planta se calcula teniendo en cuenta la cantidad de puntos salariales que se les asignan anualmente,
el valor de cada punto es de 10.000 pesos. Si el cargo del docente de planta es el de un directivo
(Jefe de departamento, Decano o Coordinador), tendrá una bonificación de 400.000 pesos sobre el
sueldo básico.

Para el caso de los docentes catedráticos el sueldo mensual estará estipulado por el número de
horas cátedra asignadas durante todo el semestre (4 meses). Si el docente catedrático tiene una
categoría de auxiliar la hora se paga a 20.000 pesos, pero si su categoría es la de asistente la hora
se paga a 25.000 pesos. Si no tiene ninguna de estas categorías la hora se paga a 15.000 pesos. A
todos los profesores de la universidad se les realiza un descuento del 6% del sueldo, por concepto
de prestaciones sociales (salud y pensión).
 Diseño de clases UML de la solución
 Implementación de la clase Persona en el fichero Persona.java

public class Persona {

//Se declara la clase persona con atributos que son generales para cualquier persona.
private int identificacion;
private String nombres;
private String apellidos;
private int edad;

//Implementación de los métodos constructores de la clase Persona.

public Persona(){
identificacion = 0;
nombres = "";
apellidos = "";
edad = 0;
}
public Persona(int id, String nom, String ape, int e){
identificacion = id;
nombres = nom;
apellidos = ape;
edad = e;
}

//Implementación de los métodos modificadores para asignar los valores a cada atributo de la
//clase Persona.
public void setIdentificacion(int id){
identificacion = id;
}
public void setNombres(String nom){
nombres = nom;
}
public void setApellidos(String ape){
apellidos = ape;
}
public void setEdad(int e){
edad = e;
}
//Implementación de los métodos selectores para obtener el valor de los atributos de la clase.
public int getIdentificacion(){
return identificacion;
}
public String getNombres(){
return nombres;
}
public String getApellidos(){
return apellidos;
}
public int getEdad(){
return edad;
}
}
 Implementación de la clase abstracta Docente en el fichero Docente.java

La clase Docente será una clase abstracta hija de la clase persona, en la cual se implementara el
método abstracto calcularSueldo().

//Se declara la clase abstracta Docente, indicando que es una clase extendida que hereda de la
//clase Persona, ya implementada. Por ser una clase abstracta se supone que se podrá declarar un
//método abstracto al interior de esta.
public abstract class Docente extends Persona{
//Se declaran los atributos o características propias de la clase Docente.
private String titulo;
private String correoInstitucional;

//Declaración de los métodos constructores de la clase Docente.

public Docente(){
super(); //Se invoca al método constructor de la superclase (Persona).
titulo = "";
correoInstitucional = "";
}
public Docente(int id, String nom, String ape, int ed, String perfil, String correo){
super(id, nom, ape, ed); //Se invoca al método constructor de la superclase (Persona).
titulo = perfil;
correoInstitucional = correo;
}

//Implementación de los métodos modificadores para los atributos de la clase Docente.

public void setTitulo(String perfil){
titulo = perfil;
}
public void setCorreoInstitucional(String correo){
correoInstitucional = correo;
}

//Implementación de los métodos selectores para obtener el valor de los atributos de la clase.
public String getTitulo(){
return titulo;
}
public String getCorreoInstitucional(){
return correoInstitucional;
}

//Declaración del método abstracto calcularSueldo(), este método no tiene cuerpo y debe ser
//sobreescrito para ser implementado en las clases hijas que se creen de la clase Docente.
public abstract double calcularSueldo();
}
 Implementación de la clase hija DocentePlanta en el fichero DocentePlanta.java

A su vez la clase DocentePlanta, es una clase hija de la clase Docente. En esta tendrá
implementación el método abstracto calcularSueldo(), declarado en la clase Docente.

public class DocentePlanta extends Docente{

//Se declaran los atributos o características propias de la clase DocentePlanta.
private int puntos;
private String cargo;

//Declaración de los métodos constructores de la clase DocentePlanta.

public DocentePlanta(){
super(); //Se invoca al método constructor de la superclase (Docente).
puntos = 0;
cargo = "";
}
public DocentePlanta(int id, String nom, String ape, int ed, String perfil, String correo, int punto, String c ){
//Se invoca al método constructor de la superclase (Docente).
super(id, nom, ape, ed, perfil, correo);
puntos = punto;
cargo = c;
}

//Métodos modificadores para los atributos de la case DocentePlanta.

public void setPuntos(int punto){
puntos = punto;
}
public void setCargo(String c){
cargo = c;

//Métodos selectores para los atributos de la case DocentePlanta.

public int getPuntos(){
return puntos;
}
public String getCargo(){
return cargo;
}

//Se sobre escribe en la clase DocentePlanta el método abstracto calcularSueldo(), declarado

/la en la clase Docente, y se implementa según la problemática planteada.
@Override
public double calcularSueldo(){
double descuento, sueldo, sueldoNeto;
if (getCargo().equals("Jefe")|| getCargo().equals("Decano") || getCargo().equals("Coordinador")){
sueldo = ((getPuntos()*12000)+400000);
descuento = (sueldo*0.06);
sueldoNeto = (sueldo - descuento);
return sueldoNeto;
}else{
sueldo = (getPuntos()*12000);
descuento = (sueldo*0.06);
 sueldoNeto = (sueldo - descuento);
return sueldoNeto;
}
}
}

 Implementación de la clase hija DocenteCatedra en el fichero DocenteCatedra.java

La clase DocenteCatedra, es una clase hija de la clase Docente. En esta tendrá implementación el
método abstracto calcularSueldo(), declarado en la clase Docente.

public class DocenteCatedra extends Docente{

//Se declaran los atributos o características propias de la clase DocenteCatedra.
private int numeroHoras;
private String categoria;

//Declaración de los métodos constructores de la clase DocenteCatedra.

public DocenteCatedra(){
super(); //Se invoca al método constructor de la superclase (Docente).
numeroHoras = 0;
categoria = "";
}
public DocenteCatedra(int id, String nom, String ape, int ed, String perfil, String correo, int nh, String cat ){
//Se invoca al método constructor de la superclase (Docente).
super(id, nom, ape, ed, perfil, correo);
numeroHoras = nh;
categoria = cat;
}

//Métodos modificadores para los atributos de la case DocenteCatedra.

public void setNumeroHoras(int nh){
numeroHoras = nh;
}
public void setCategoria(String cat){
categoria = cat;
}

//Métodos selectores para los atributos de la case DocenteCatedra.

public int getNumeroHoras(){
return numeroHoras;
}
public String getCategoria(){
return categoria;
}

//Se sobre escribe en la clase DocenteCatedra el método abstracto calcularSueldo(), declarado en

//la clase Docente. y se implementa según la problemática planteada.
@Override
public double calcularSueldo(){
double descuento, sueldo, sueldoNeto;
if(getCategoria().equals("auxiliar")){
sueldo = (getNumeroHoras()*20000)/4;
descuento = (sueldo*0.06);
 sueldoNeto = (sueldo - descuento);
return sueldoNeto;
}else{
if(getCategoria().equals("asistente")){
sueldo = (getNumeroHoras()*25000)/4;
descuento = (sueldo*0.06);
sueldoNeto = (sueldo - descuento);
return sueldoNeto;
}else{
sueldo = (getNumeroHoras()*15000)/4;
descuento = (sueldo*0.06);
sueldoNeto = (sueldo - descuento);
return sueldoNeto;
}
}
}
}

 Implementación de la clase Main en el fichero Main.java

public class Main {

//Se implementa el método con el menú de opciones de la aplicación.
public static int menu(){
int opcion = 0;
do{
opcion = Integer.parseInt(JOptionPane.showInputDialog("===== IMPLEMENTACIÓN DE
HERENCIA - OPCIONES DEL MENÚ ===== \n\n"+
"1. Calcular Salario Docentes de Planta \n"+"2. Calcular Salario Docentes Catedrático \n"+
"3. Salir \n"+ "\n\n Seleccione una opción del 1 al 3"));
}while(opcion <= 0 || opcion > 3);
return opcion;
}

//Se crea el método que permite capturar la información correspondiente a cualquier docente.
//Se pasa como parámetro un objeto de la clase Docente para enviar la información capturada
//a los respectivos métodos modificadores.
public static void capturarDatos(Docente doc){
int id = Integer.parseInt(JOptionPane.showInputDialog(null, "Digite la identificación del Docente:"));
doc.setIdentificacion(id);
String nombre = JOptionPane.showInputDialog(null, "Digite Nombre del Docente:");
doc.setNombres(nombre);
String apellido = JOptionPane.showInputDialog(null, "Digite Apellido del Docente:");
doc.setApellidos(apellido);
int edad = Integer.parseInt(JOptionPane.showInputDialog(null, "Digite la Edad del Docente:"));
doc.setEdad(edad);
String titulo = JOptionPane.showInputDialog(null, "Digite el Titulo del Docente:");
doc.setTitulo(titulo);
String correo = JOptionPane.showInputDialog(null, "Digite el Correo Institucional del Docente:");
doc.setCorreoInstitucional(correo);
}

public static void main(String[] args) {

//Se crea los objetos de las clases DocentePlanta (dp) y DocenteCatedra (dc).
 DocentePlanta dp = new DocentePlanta();
DocenteCatedra dc = new DocenteCatedra();
int opcion;
do{
opcion = menu();
switch(opcion) {
case 1:
//En la primera opción del menú, se captura la información del docente de planta
//y se realiza el caculo de su sueldo.
capturarDatos(dp);
int puntos = Integer.parseInt(JOptionPane.showInputDialog(null, "Digite los Puntos Asignados al
Docente:"));
dp.setPuntos(puntos);
String cargo = JOptionPane.showInputDialog(null, "Digite el Cargo (Jefe, Decano, Coordinador,
ninguno):");
dp.setCargo(cargo);
JOptionPane.showMessageDialog(null, "===== CALCULO SUELDO NETO DOCENTE
UNIVERSITARIO ===== \n\n"+
"DATOS GENERALES DEL DOCENTE: \n"+
dp.getIdentificacion()+"\n"+dp.getNombres()+" "+dp.getApellidos()+"\n"+dp.getEdad()+"
años \n\n"+
"INFORMACIÓN ACADÉMICA: \n"+
dp.getTitulo()+"\n"+dp.getCargo()+"\n"+dp.getCorreoInstitucional()+
"\n\nSUELDO NETO MENSUAL: \n"+dp.calcularSueldo());
break;
case 2:
//En la segunda opción del menú, se captura la información del docente de cátedra
//y se realiza el caculo de su sueldo.
capturarDatos(dc);
int nh = Integer.parseInt(JOptionPane.showInputDialog(null, "Digite No. de horas asignadas el
semestre:"));
dc.setNumeroHoras(nh);
String categoria = JOptionPane.showInputDialog(null, "Digite Categoría (auxiliar, asistente,
ninguna):");
dc.setCategoria(categoria);
JOptionPane.showMessageDialog(null, "===== CALCULO SUELDO NETO DOCENTE
UNIVERSITARIO ===== \n\n"+
"DATOS GENERALES DEL DOCENTE: \n"+
dc.getIdentificacion()+"\n"+dc.getNombres()+" "+dc.getApellidos()+"\n"+dc.getEdad()+"
años \n\n"+
"INFORMACIÓN ACADÉMICA: \n"+
dc.getTitulo()+"\n"+dc.getCategoria()+"\n"+dc.getCorreoInstitucional()+
"\n\nSUELDO NETO MENSUAL: \n"+dc.calcularSueldo());
break;
case 3:
break;
}
}while(opcion != 3);
}
}
 EJERCICIOS/ACTIVIDADES

1. Para el ejercicio propuesto anterior, almacenar en un vector de objetos, elementos de las clases
DocenteCatedra y DocentePlanta, posteriormente listar la información.

2. Diseñe una jerarquía de clases para los datos de un estudiante de una universidad,
correspondientes a número de matrícula, programa académico, nombres, apellidos, semestre.
Tenga en cuenta que existen tres tipos de estudiantes, además de los estudiantes comunes: los
egresados, los de modalidad a distancia y los de postgrado. En el caso de los egresados se debe
guardar su año de graduación y el cargo que actualmente desempeñan. Para los estudiantes a
distancia se almacenan cuántas materias está cursando. En el caso de los de postgrados, se
guarda el nombre del postgrado cursado y la universidad de la cual proviene.

3. Simular la creación de ficheros dentro de un sistema operativo, para ello se establece la

siguiente información. Cualquier fichero mantiene un registro de los siguientes datos:
identificador del fichero, nombre del fichero y permisos de acceso. Dentro de un sistema
operativo existen dos tipos de ficheros, los de tipo archivo y tipo directorio. Para un archivo se
debe tener una extensión y la información que esta almacena (número de caracteres). Para un
directorio se mantiene únicamente la cantidad de sub-directorios que este posee. De igual
forma es necesario aclarar que para calcular el tamaño en disco de cada tipo de fichero en bytes
se establecen estos dos criterios:

Si es un archivo, su tamaño está definido por la siguiente expresión:

tamano=numero_de_caracteres*3

Si es un directorio, su tamaño está definido por la siguiente expresión:

tamano=cantidad_subdirectorios*2
 BIBLIOGRAFÍA

[1] Rodríguez, Alex. (s.f.). Curso Aprender programación Java desde cero - Resumen de ventajas
de la herencia en Java. Recuperado de:
http://www.aprenderaprogramar.com/index.php?option=com_content&view=article&id=673:res
umen-de-ventajas-de-la-herencia-en-java-avanzar-en-java-swing-gestion-de-errores-y-mas-
cu00698b&catid=68&Itemid=188

[2] Rodríguez, Alex. (s.f.). Curso Aprender programación Java desde cero - Clases y métodos
abstractos en Java. Recuperado de:
http://www.aprenderaprogramar.com/index.php?option=com_content&view=article&id=668:cla
ses-y-metodos-abstractos-en-java-abstract-class-clases-del-api-ejemplos-codigo-y-ejercicios-
cu00695b&catid=68&Itemid=188