UNIVERSIDAD DE PANAMÁ

CENTRO REGIONAL UNIVERSITARIO DE VERAGUAS

FACULTAD DE INFORMÁTICA ELECTRÓNICA Y COMUNICACIÓN
LICENCIATURA EN INFORMÁTICA PARA LA GESTIÓN EDUCATIVA Y
EMPRESARIAL

LABORATORIO #3

PROGRAMACIÓN IV

JERARQUÍA Y HERENCIA

PERTENECE A:

ORADYS BATISTA 9-721-869

PROFESOR:

DIEGO SANTIMATEO

2006

INTRODUCCIÓN
 En este trabajo vamos a conocer y a poner en practica la Jerarquía y la
Herencia los cuales juegan un papel importante en la programación Orientada a
Objetos. El trabajo involucra diferentes fuentes de información que he recurrido
para la clara comprensión de los conceptos involucrados, cabe mencionar que en
este trabajo presento ejemplos de cada concepto involucrado como también una
aplicación apoyada en una propuesta UML.

Laboratorio # 3

Fase #1

Fuentes de información

Oradys Batista HERENCIA Y JERARQUÍA 2

 • Manzanedo, M.; García, P. ; García, F.; Actualizado el 13 de octubre de
1999.[Documento en línea]. Guía de inicialización al lenguaje Java,
Salamanca . Disponible desde Internet en:
<http://pisuerga.inf.ubu.es/lsi/Invest/Java/Tuto/II_6.htm> [con acceso el 8-11-
2006]
Comentario:
Este documento presenta información sobre el lenguaje Java como también
conceptos importantes de la programación Orientada a Objetos como la herencia
de clases, clases abstractas, polimorfismo, sobrecarga, composición entre otros.

• Müller ,P.; Globewide. Actualizado en Agosto 31, 1997.[Documento en

línea].Programación orientada a objeto, Network Academy (GNA).
Disponible desde Internet en :
<http://www.gnacademy.org/text/cc/Tutorial/Spanish>.[con acceso el 8-11-
2006 ]
Comentario:
La fuente anterior se trata de las principales características de la programación
orientada a objetos en la que esta muy íntimamente ligada la herencia en la que
nosotros podemos forzar a una subclase para que ofrezca las mismas propiedades
de sus superclases, Jerarquía, clases abstractas, sobrecarga.

• Román, C. [Documento en línea ].Programación con Java. Facultad de

Ingeniería, UNAM. Disponible desde Internet:<http://www.fi-.
unam.mx/pp/profesores/carlos/java/indice.html>.[con acceso el 8-11-2006]
Comentario:
Esta fuente de información nos proporciona información acerca la Tecnología Java,
Estructura del Lenguaje, Conceptos de OO como Herencia, Superclase, Subclases,
Polimorfismo y Abstracción las cuales han sido muy importante para nuestra
investigación.

• Rodríguez, D. 1999-2006. Introducción a Java.[Documento en línea].

Disponible en Internet en:
<http://www.programacion.com/java/tutorial/intjava/9/>. [con acceso el 8-11-
2006]
Comentario:
La dirección anterior posee información referente a Polimorfismo, Herencia,
Sobrecarga. En esta dirección podemos identificar que cuando utilizamos la
herencia podemos terminar teniendo una familia de clases que comparten un
interfaz común. Todo conlleva una relación en la que las subclases heredan
atributos de la superclase esto se denomina herencia ya que heredan métodos y

Oradys Batista HERENCIA Y JERARQUÍA 3

atributos de una clase posterior, muy relacionado a estos esta el polimorfismo el
cual permite sobrescribir en las subclases los métodos de la superclase y así una
misma operación puede estar relacionada a métodos distintos en clases diferentes.

• Puchol, A. 26-1-2001.; 17-Junio-2001. [Documento en línea].Apuntes del

lenguaje Java. Disponible en Internet
en:<http://www.arrakis.es/~abelp/ApuntesJava/indice.htm> También
disponible
en:<http://www.geocities.com/belpuchol/ApuntesJava/indice.htm>.[con
acceso el 8-11-2006]
Comentario:
Estas dos direcciones antes mencionada nos llevan a conocer mas sobre la herencia
de clases , sobrecarga de métodos en la que una clase puede tener métodos con los
mismos nombres , clase abstracta en la que una clase puede declarar un método sin
implementarlo y otras cosas importantes en la programación OO.

• Chemi. Actualizado el (18-ene-2005). JavaHispano 2001-2005.[Documento

en línea]. Disponible en Internet en:
<http://www.javahispano.org/cursotext.viewer.action?file=basico>. [con
acceso el 8-11-2006]
Comentario:
La fuente de información antes mencionada nos proporciona información acerca de
los elementos de Java el mismo presenta una serie de tutórales descargables en los
que pude encontrar documentación sobre la herencia, jerarquía de clases conceptos
de super, this, sobrecarga los cuales conceptos fundamentales para nuestra
investigación.

• Tutorial de Java, API, Versión 3.0.[Documento en línea].Disponible en

Internet en:< http://www.cica.es/formacion/JavaTut/Cap1/abstr.html>.[con
acceso el 8-11-2006]
Comentario:
Esta fuente de información se refiere a todos y cada uno de los conceptos que
contiene Java y es importante mencionar que en el mismo encontramos ejemplos y
una excelente definición de Herencia como también de clases abstractas, ambas
juegan un papel importante en nuestra investigación ya que son unas de las
principales características de la programación Orientada a Objetos.

• Menéndez, j.07-11-04.[Documento en línea].Disponible en Internet

en: <http://www.mailxmail.com/curso/informatica/java/capitulo8.htm >.[con
acceso el 8-11-2006]

Oradys Batista HERENCIA Y JERARQUÍA 4

Comentario:
La fuente anteriormente mencionada nos proporciona información acerca de las
características del lenguaje Java, una pequeña introducción a la programación OO,
entre estos se encuentran la Herencia, Polimorfismo, clases, arreglos entre otros. Es
importante mencionar que esta fuente identifica con una excelente relación la
Herencia y el polimorfismo ya que es uno de los elementos esenciales de la
programación OO, también pude identificar que el polimorfismo se da cuando
varios objetos de distintas clases pueden responder el mismo mensaje y ser capaces
de responderlo, este es uno de mis principales llamados de atención con relación a
esta fuente.

• Franco, A. Curso de Lenguaje Java, Enero de 2000. Procedimientos

Numéricos en Lenguaje Java: Diciembre de 2001.[Documento en
línea].Disponible en Internet en:
<http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/herencia/herencia
1.htm>.[con acceso el 8-11-2006]
Comentario:
En esta fuente pude determinar que un lenguaje de programación Orientado a
Objetos puede organizar el código en clases compuestas con datos funciones y a
través de la característica de la herencia podemos organizar las clases en jerarquías.
Esta fuente hace énfasis en el esfuerzo que se requiere para comprender la
propiedades y el comportamiento de un tipo de objeto, transformarlos en la
definición de una clase, estructurar la clases en jerarquías, construirlos en procesos
de abstracción que implican un cambio de mentalidad en la resolución de los
problemas. La jerarquía de clases permiten que las clases reciban atributos y
métodos de otras posteriores, por lo que las clases abstractas solo se pueden usar
como base para otras clases.

• Froufe, A. Ultima Actualización: lunes, 17 de Mayo de 1999. Tutorial de

Java.[Documento en línea]. Disponible en:
<http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte5/cap5-
6.html>.[con acceso el 8-11-2006]
Comentario:
En esta fuente pude encontrar información acerca de la herencia en la que se
especifica el significado especial que juegan los constructores ya que la clases
heredada necesita que se ejecute el constructor de la clase posterior antes que su
propio constructor para que de esta forma se inicialicen las variables heredadas de
la superclase.

• Programación Orientada a Objetos.[Documento en línea].Disponible en:

Oradys Batista HERENCIA Y JERARQUÍA 5

<http://ieee.udistrital.edu.co/concurso/programacionII/Programacion2/html/book1.
html>.[con acceso el 11-11-2006]
Comentario:
Esta es una página una muy completa ya que contiene la características principales
de Programación Orientada a Objetos , conceptos sobresalientes del lenguaje Java
y diversos ejemplos los cuales podemos comprobar y evaluar para nuestra mayor
comprensión del tema.

• Ordax, J, M .Creado el : 13-11-2004. PDF, Java Básico. Aplicación

Pscript5.dll Versión 5.2. [Documento en línea].Disponible en: Tutorial Adobe
Reader-[m2ch5.pdf]. [con acceso el 13-11-2006]
Comentario:
En el tutorial antes observamos encontramos información acerca de la herencia en
la que se pudo encontrar ejemplos y algunos ejercicios que no ayudaran a
identificar ,comprender y manipular problemas a la hora de resolver los mismos.
También este tutorial presenta las clases objeto.

Glosario

1. Jerarquía: consiste en la relación entre clases ya que estas no están

aisladas. Las clases heredadas heredan datos de las posteriores formando
una estructura jerárquica de las clases.
2. Herencia: en la Programación Orientada a Objetos es un mecanismo el
cual permite derivar una clase de otra, es decir que recibe la mismas

Oradys Batista HERENCIA Y JERARQUÍA 6

 particularidades de la clase posterior evitando así la repetición de código
y proporciona una mejor intuición de mismo, a través de la herencia las
clases derivadas reciben datos, métodos o funciones de la súper clase o
clase base. La principal función de la herencia es proveer polimorfismo.
Debemos usar la herencia cuando hay una clase de un tipo mas
especifico que una superclase.
3. extends: esta palabra clave se usa para generar una subclase
(especificación) de un objeto.
4. Polimorfismo: como su nombre lo indica poli(mucho) morfismo(formas)
en la que una referencia a un objeto de una clase da una referencia a un
objeto de una clase que ha sido heredada .Dicho de otro modo diferentes
comportamientos relacionados a distintos objetos los cuales pueden
compartir el mismo nombre al llamarlos y por ello se utilizara el
comportamiento correspondiente al objetos en uso.
5. Clase abstracta: se refiere a la existencia de las clases que no hayan sido
instanciadas ya que posee métodos abstractos que han sido definidas es
decir sin implementación. Esta clase se denota con el nombre de la clase
y de los métodos. Esto es muy útil cuando la implementación es
específica para cada usuario, pero todos los usuarios tienen que utilizar
los mismos métodos .No se pueden crear objetos pertenecientes a esta
clase.
6. Abstracts: esta palabra clave es utilizada para hacer referencia a las
clases abstractas.
7. This: al acceder a variables de instancias de una clase, esta palabra hace
referencia a los miembros de su propia clase.
8. Super : si se necesita llamar al método padre dentro de una clase que ha
remplazado ese método, se puede hacer referencia al método padre con la
palabra clave super.
9. Súper Clase: es la clase base superior que contiene el nombre de la
clase.
10. Sobrecarga: características de definir métodos con el mismo nombre
diferentes en tipos o número de los argumentos. Sobrecargar un método
es distinto a sobrescribir un método. La sobrecarga concite en tener
varias implementaciones del mismo métodos con distintos parámetros.
11. Interfases: Un interfase declara un conjunto de métodos y constantes sin
especificar su implementación para ningún método. Los métodos de clase
son public , static y proporcionan un mecanismo de encapsulación.
12. Public: Las clases public son accesibles desde otras clases, bien sea
directamente o por herencia. Son accesibles dentro del mismo paquete en

Oradys Batista HERENCIA Y JERARQUÍA 7

 el que se han declarado. Para acceder desde otros paquetes, primero
tienen que ser importadas.
13. Subclase: Esta es una clase que desciende de otra heredando el estado y
comportamiento de sus clases posteriores, esta clase se convierte cada
vez mas especializada ya que a medida que aumentan las clases estas se
continúan heredando.
14. Constructores: permiten que en una clase haya sobrecarga

Ejemplification

CLASE ABSTRACTA
En esta aplicación el dominio es un Restaurante. La clase Cocinero es la
superclase Abstracta y contiene el método imprimir el cual es abstracto. Como
podemos ver la clase mesero hereda de la clase cocinero y podemos hacer uso de el
método imprimir mediante el llamado del objeto de la clase Mesero.

Oradys Batista HERENCIA Y JERARQUÍA 8

import javax.swing.*;
import java.text.*;
class Restaurante /*Clase Principal*/
{
public static void main(String args[]){
/*Creación del objeto mesero*/
Mesero objeto = new Mesero();
objeto.imprimir();
}}
/*Clase Abstracta*/
abstract class Cocinero {
public abstract void imprimir();
}
class Mesero extends Cocinero {/*El mesero se comunica con el cosinero */
public void imprimir(){
System.out.println("Digame Joven que Desea");
System.out.println("Tenemos Comida Corriente");
System.out.println("Sancocho");
System.out.println("Arroz con camarones");
}}

HERENCIA
El dominio de esta aplicación es una Empresa la clase empleado es la superclase
y la clase ejecutivo es heredera de esta.
import java.lang.String.*;
import java.text.*;
import javax.swing.*;
class Empresa /*Clase principal*/
{
public static void main(String [] args)
{
String mg,nom,i,ii;
int ed;
Capturar bb= new Capturar();
mg="introduzca el nombre ejecutivo";
nom=bb.Captura(mg);
mg="introduzca la edad";
ed=Integer.parseInt(bb.Captura(mg));
/*Creación de Objetos*/

Oradys Batista HERENCIA Y JERARQUÍA 9

 Empleado datos=new Empleado(nom,ed);
Ejecutivo obeje=new Ejecutivo(nom,ed);
System.out.println("Salario Aumentado:"+obeje.SalarioAumentado());
System.exit(0);
}}
class Empleado /*Súper Clase */
{
String Nombre;
int Edad;
public Empleado(String Nomb,int Edd) { /*Constructor de la clase*/
Nombre=Nomb;
Edad=Edd;
}
public String getNombre()
{
return (Nombre);
}
public int getEdad()
{
return (Edad);
}
}

class Ejecutivo extends Empleado /*El ejecutivo es un empleado*/

{
public Ejecutivo(String Nomb,int Edd)
{
super(Nomb,Edd); /*este método permite hacer llamado al
método padre*/
System.out.println("****:"+Nomb);
}
public int SalarioAumentado(){ /*Aumento del salario al ejecutivo*/
int salario,sall;
int aumento=50;
String dat;
dat=JOptionPane.showInputDialog(null,"Introduzca su salario");
sall=Integer.parseInt(dat);
salario=sall + aumento ;
return(salario);
}

Oradys Batista HERENCIA Y JERARQUÍA 10

}
POLIMORFISMO

El dominio de esta aplicación es la clase Restaurante. como clase principal la

clase cocinero en la que se hace uso de un método CantidePedidos el cual es cero
el pedido realizado en esta clase se hace uso del metodo CantidePedidos en el
que se despliega el menu y retorna el numero de pedido que en ese momento se
realizo.
import javax.swing.*;
import java.text.*;
class Restaurante
{ /*Clase principal*/
public static void main(String args[])
{
int pedidos,ve;
ve=2;
Cocinero cos=new Cocinero(ve); /*Objeto de la clase cocinero*/
cos.CantidePedidos(); /*llamados al método de esta clase*/
Mesero objeto = new Mesero(ve);
pedidos=objeto.CantidePedidos();
System.out.println("cantidad de pedidos:"+ pedidos);
}}
public class Cocinero /*Super clase*/
{
int ventas;
public Cocinero (int ven)
{
ventas=ven;
}
public void CantidePedidos()/*Aquí hay polimorfismo*/
{
int cantidad=0;
System.out.println("Pedidos:"+cantidad);
}}
class Mesero extends Cocinero {
public Mesero(int ven) {
super(ven);
}
public int CantidePedidos() /*Aquí hay polimorfismo*/
{

Oradys Batista HERENCIA Y JERARQUÍA 11

 System.out.println("Digame Joven que Desea");
System.out.println("Tenemos Comida Corriente");
System.out.println("Sancocho");
System.out.println("Arroz con camarones");
return 1;
}
}

SOBRECARGA
El dominio de esta aplicación es la clase Escuela el mismo presenta una
sobrecarga de métodos en la clase estudiante
Esta aplicación representa todos los datos de los estudiantes
import java.text.*;
import javax.swing.*;
import java.lang.String.*;
class Escuela
{
public static void main(String[] args)
{
String concat,msg,nomm,cedd,s;
int edd,ss,j;
Capturar datos=new Capturar();
Estudiante[] vect=new Estudiante[10];
int i=0;
do{

msg="introduce el nombre";
nomm=datos.Captura(msg);
msg="Introduzca su Edad";
edd=Integer.parseInt(datos.Captura(msg));
msg="Introduzca su cedula";
cedd= datos.Captura(msg);
Estudiante datest=new Estudiante(nomm,edd,cedd);
vect[i]=datest;
s=JOptionPane.showInputDialog(null,"si desea continuar preciona 0:");
ss=Integer.parseInt(s);
i++;
}while(ss==0);

Oradys Batista HERENCIA Y JERARQUÍA 12

 System.out.println(" Nombre.Edad.Cedula");
for(j=0;j<i;j++)
{
concat=vect[j].getNombre()+" "+vect[j].getEdad()+" "+vect[j].getCedula();
datos.Desplegar(concat);
}
System.exit(0);
}
}
class Estudiante /*Super clase*/
{
String nombre;
int edad;
String cedula;
/* El constructor de la clase Estudiante esta sobrecargado */
Estudiante( )
{
nombre = null;
edad = 0;
cedula = null;
}
/*La clase estudiante esta sobrecargado con direrentes tipos de argumentos*/
Estudiante(String nom, int ed, String ced) {
this.nombre = nom;
this.edad = ed;
this.cedula = ced;
}
/*La clase estudiante esta sobrecargado y tiene como
argumento una variable que tiene como tipo la clase*/
Estudiante(Estudiante usr) {
nombre = usr.getNombre();
edad = usr.getEdad();
cedula = usr.getCedula();
}
void setNombre(String n) {
nombre = n;
}
String getNombre() {
return nombre;
}

Oradys Batista HERENCIA Y JERARQUÍA 13

 /*El metodo setEdad() está sobrecargado */
void setEdad(int e) {
edad = e;
}
void setEdad(float e) {
edad = (int)e;
}
int getEdad() {
return edad;
}
void setCedula(String d) {
cedula = d;
}
String getCedula()
{
return cedula;
}
}

Aplicación Ejecutable

Esta aplicación tiene como dominio una empresa en la que se determina las
funciones que ejercen algunos funcionarios de la misma, como superclase esta la
clase Empleado y como herederas de esta clase las clases Ejecutivo y Secretaria.

Oradys Batista HERENCIA Y JERARQUÍA 14

En nuestra aplicación hemos podido hacer uso de los conceptos de la programación
OO que hemos investigado como lo son la herencia de clases, el polimorfismo, la
sobrecarga de métodos y clase abstracta
La Superclase Empleado , esta clase tiene el nombre del empleado, edad y salario
, como sabemos todo empleado tiene estos atributos y los mismos son heredados
por la Clase Ejecutivo y la Clase Secretaria; es importante mencionar que el
ejecutivo ejerce tareas diferentes a la secretaria pero ambos son empleado de la
empresa.
La clase empleado también cuenta con un método sobrecargado, que utilizo para
asignarle valor a las variables de la clase .
Aplique polimorfismo al método BonoEmpleado de la clase Empleado para luego
aplicarle un bono a la clase heredada Secretaria .

class Empresa /*Clase Dominio*/

{
public static void main(String [] args) /*Clase principar Void Main*/
{
String nomm,msg,s,sal;
int edd,ss,i,cod,j;
float sall,cap,bon;
int[] codigos=new int[10];
Capturar cat=new Capturar();
i=0;
do
{ /*Llamados a la clase captura*/
msg="introduce el nombre del Ejecutivo";
nomm=cat.Captura(msg);
msg="Introduzca su Edad";
edd=Integer.parseInt(cat.Captura(msg));
msg="Introduzca su salario";
sal=cat.Captura(msg);
sall=Float.parseFloat(sal);
msg="Introduzca el Capital de la empresa";
sal=cat.Captura(msg);
cap=Float.parseFloat(sal);
Empleado dato=new Empleado(nomm,edd,sall,cap);
Ejecutivo eje=new Ejecutivo(nomm,edd,sall,cap); /*Objetos de la clase
heredada Ejecutivo*/
Secretaria dat=new Secretaria(nomm,edd,sall,cap);/*Objetos de la clase
heredada Secretaria*/

Oradys Batista HERENCIA Y JERARQUÍA 15

 /*Impresión y llamado de los datos del
Ejecutivo*/
System.out.println("Nombre del Ejecutivo :"+eje.getNombre());
System.out.println("Su Edad:"+eje.getEdad());
System.out.println("Su Salario:"+eje.getSalario());
System.out.println("Salario Aumentado:"+eje.AumentoEjecutivo());

codigos[i]=eje.InformeCodigo(); /*Vector que contiene los códigos de los

Ejecutivo*/
dat.ComprasRealizadas(); /*Llamado al método compras realizadas por la
secretaria*/
bon=dat.BonoEmpleado(); /*Llamado al método BonoEmpleado para la
Secretaria*/
System.out.println("Resibio un bono en Fenix de:"+bon);

s=JOptionPane.showInputDialog(null,"si desea continuar preciona 0:");

ss=Integer.parseInt(s);
i++;
}while(ss==0);
/*Códigos de los ejecutivos de las distintas empresas*/
for(j=0;j<i;j++)
{
System.out.println("Cogido de Ejecutivo:"códigos[j]);
}
System.exit(0);
}
}

class Empleado /*Super Clase Empleado */

{
String Nombre;
int Edad;
float Salario,Capital;
public Empleado(String Nombr,int Eda,float Salari,float Capt) /*Constructor de la
clase empleado*/
{
Nombre=Nombr;
Edad=Eda;
Salario=Salari;
Capital=Capt;

Oradys Batista HERENCIA Y JERARQUÍA 16

}
public String getNombre()
{
return Nombre;
}
public int getEdad()
{
return Edad;
}
public float getSalario()
{
return Salario;
}
public float getCapital()
{
return Capital;
}
public float BonoEmpleado() /*Aqui hay Polimorfismo*/
{
return (0);
}

Empleado(Empleado usr) /*Aqui hay sobrecargada*/

{
Nombre = usr.getNombre();
Edad = usr.getEdad();
Salario= usr.getSalario();
}
}
class Ejecutivo extends Empleado /*El ejecutivo es un empleado*/
{
int codigos;
public Ejecutivo(String Nombre,int Edad,float Salario,float Capital)
{
super(Nombre,Edad,Salario,Capital);
}
public float AumentoEjecutivo() /*Aumento de salario a Ejecutivo*/
{
if(Salario>300.00 )
{

Oradys Batista HERENCIA Y JERARQUÍA 17

 Salario=Salario+50;
return(Salario);
}
else
return(Salario);
}
public int InformeCodigo() /*Codigo del Ejecutivo*/
{
String s;
int cod;
s=JOptionPane.showInputDialog(null,"Indique su codigo:");
cod=Integer.parseInt(s);
return(cod);
}
}
class Secretaria extends Empleado /*La Secretaria es un empleado*/
{
public Secretaria(String Nombre,int Edad,float Salario,float Capital)
{
super(Nombre,Edad,Salario,Capital);
System.out.println("Capital Actual:"+Capital);
}
public void ComprasRealizadas() /*Compras realizadas por la Secretaria */
{
String s,ss,p,cc;
int cant,cantt,i;
float salario,precio,costo,sum,cap;
s=JOptionPane.showInputDialog(null,"Cantidad de articulos pedidos el dia de
hoy por la Secretaria:");
cant=Integer.parseInt(s);
sum=0;
for(i=0;i<cant;i++)
{ ss=JOptionPane.showInputDialog(null,"Indique el Nombre del articulo:");
cc=JOptionPane.showInputDialog(null,"Cantiadad de este articulo:");
cantt=Integer.parseInt(cc);
p=JOptionPane.showInputDialog(null,"Precio del articulo:");
precio=Float.parseFloat(p);
costo=cantt*precio;
sum=sum+costo;

Oradys Batista HERENCIA Y JERARQUÍA 18

 }
cap=Capital-sum;
System.out.println("*********Informe de compra de Secretària*********");
System.out.println("Total Gastado en esta compra:"+sum);
System.out.println("Capital Actual:"+cap);
}
public float BonoEmpleado() /*Aqui hay Polimorfismo*/
{
float bono= 100;
System.out.println("Te ganaste un bono de B/.100 en Fenix Center");
return(bono);
}
}

Oradys Batista HERENCIA Y JERARQUÍA 19

 Aplicación apoyada en propuesta UML

///Empleado\\\

Nombre
Edad
///Empresa\\\ Salario
Capital

Public Empleado()
Void main()/*Clase public String getNombre()
principal */ public int getEdad()
public float getSalario()
public float getCapital()
public float BonoEmpleado()
Empleado(Empleado usr)

///Secretaria\\\
///Ejecutivo\\\

Códigos public Secretaria()

public void ComprasRealizadas()
public Ejecutivo() public float BonoEmpleado()
public float AumentoEjecutivo()
public int InformeCodigo()

Oradys Batista HERENCIA Y JERARQUÍA 20