Proyecto 3

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
PROGRAMACIÓN IV
TEMA
JERARQUÍA Y HERENCIA
FACILITADOR
DIEGO SANTIMATEO
ELABORADO POR
CALLES YORISBETH 9-720 -2373

Tema: Jerarquía y Herencia
GONZÁLEZ ROMAN 9- 705-1420
II AÑO
II SEMESTRE
FECHA DE ENTREGA
12 DE NOVIEMBRE DE 2007
2
Tema: Jerarquía y Herencia
ÍNDICE
Introducción......................................................................................................................................i
1. FUENTES DE INFORMACIÓN REFERENTES AL LENGUAJE JAVA.................................1
2. GLOSARIO DE TÉRMINOS .....................................................................................................6
3. EJEMPLIFICACIÓN DE CONCEPTOS..................................................................................10
3.1 Clase abstracta.....................................................................................................................10
3.2 Interfaz ................................................................................................................................11
3.3 Sobrecarga............................................................................................................................12
3.4 Herencia y Superclase..........................................................................................................14
3.5 Polimorfismo.......................................................................................................................15
4. PRESENTACIÓN DE UNA APLICACIÓN EJECUTABLE...................................................17
4.1 Descripción del Dominio:...................................................................................................17
4.2 Descripción de las clases....................................................................................................18
4.3 Clases involucradas en el programa....................................................................................21
4.4 Código fuente:.....................................................................................................................22
4.5 Ejecución del Programa .....................................................................................................32
5. Diagrama UML.........................................................................................................................35
6. Reflexión sobre el trabajo en equipo.........................................................................................30
6.1. Cómo fue la labor de los integrantes..................................................................................30
6.2. Metodología propuesta para el desarrollo de este proyecto...............................................30
7. Evaluación individual de la experiencia...................................................................................32
1
INTRODUCCIÓN
En este proyecto que presentaremos a continuación trata de la Herencia y
la Jerarquía, en los cuales utilizamos fuentes de información relacionados con
los tema, para ello ejemplificamos por medio de programas los conceptos de
herencia, jerarquía, polimorfismo, clase abstracta, sobre carga, etc. Adicional
presentamos un glosario de términos referentes a los temas tratados en el
proyecto, y finalizamos el proyecto con un programa ejecutable en java
donde implementamos los temas utilizados en el proyecto.
i
1. FUENTES DE INFORMACIÓN REFERENTES AL LENGUAJE JAVA
1.Autor desconocido, “Interfaces” [en línea], [act. Enero de 2000], Disponible en Internet
http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/herencia/interfa
ces.htm <Consulta: 6 de noviembre de 2007>
En esta página encontramos el concepto y ejemplos de interfaz donde
podemos decir que Un interface es una colección de declaraciones de
métodos (sin definirlos) y también puede incluir constantes.
También podemos encontrar:
•La diferencia entre interface y una clase abstracta donde se dice que un
interface es simplemente una lista de métodos no implementados,
además puede incluir la declaración de constantes. Una clase abstracta
puede incluir métodos implementados y no implementados o abstractos,
miembros dato constantes y otros no constantes.
•Los interfaces y el polimorfismo
2.Autor desconocido, Tutorial de JAVA, “Interfaces” [en línea], {Act. lunes,

17 de Mayo de 1999], Disponible en Internet <http://www.itapizaco.e-
du.mx/paginas/JavaTut/froufe/parte5/cap5-12.html> [Consulta: 6 de no-
viembre de 2007]
En este tutorial podemos encontrar el concepto de Interfaz, como:
La definición de un interfaz es semejante a la de una clase. La definición de
Elaborado por: Calles Yorisbeth y González Roman 1

interfaz tiene dos componentes, declaración y cuerpo.
La declaración de interfaz puede tener dos componentes adicionales, el
especificador de acceso public y la lista de superinterfaces.
Una clase puede implementar más de un interfaz, incluyendo varios nombres
de interfaces separados por comas.
Además en esta web podemos encontrar la Herencia múltiple.
3.Autor desconocido, Interfaz, arreglo y polimorfismo [en línea], [Act. ]

Disponible en Internet
http://javabasico.osmosislatina.com/curso/polimorfismo.htm#int
[Consulta: 6 de noviembre de 2007]
En esta web podemos encontrar temas de mucha utilidad en este proyecto,
donde además encontramos ejemplos de mucha utilidad los cuales nos
sirvieron para tomarlo como ejemplos para poder resolver dudas.
4.Autor desconocido,”Métodos y clases abstractas” [en línea ] [Act]

Disponible en Internet http://pjsml.50megs.com/java/herencia4.html
[Consulta: 6 de noviembres de 2007]
Un método abstracto es un método que declara una funcionalidad que debe
ser implementada en todas las clases derivadas, en que se vaya a utilizar. En
esta página además de su definición podemos encontrar ejemplos de cómo
utilizar la clase abstracta.

5.Autor desconocido, “Herencia Programación Orientada a Objeto” [en
línea], disponible en Internet, [Act. 02:05, 6 nov 2007]
http://es.wikipedia.org/wiki/Herencia_(programaci%C3%B3n_orientada_a_
objetos)#Ejemplo_de_herencia [Consulta: 6/11/2007]
En esta página podemos encontrar información sobre la Herencia donde
podemos decir que la Herencia es uno de los mecanismos de la
programación orientada a objetos, por medio del cual una clase se deriva de
otra, llamada entonces superclase, de manera que extiende su funcionalidad.
También podemos encontrar ejemplos de herencia, podemos decir que hay
dos tipos de herencia que es la herencia simple y la herencia múltiple.
6.Autor desconocido,” Subclases y Herencia” [en línea], [Act.] Disponible

en Internet http://www.dcc.uchile.cl/~lmateu/Java/Apuntes/subclase.htm
[Consulta: 6/11/2007]
En esta página podemos encontrar temas relacionados con subclases, je-
rarquías, clases abstractas. Los cuales se nos explica la relación que puede
existir entre ellos, y aclarar lo que se puedes y no se debe hacer.

7.Autor Daniel Rodríguez Herrera, “Tutorial Introducción a Java”,”Herencia”
[en línea], [Act], Disponible en Internet
http://www.programacion.com/java/tutorial/intjava/8/
[Consulta:6/11/2007]
En esta página podemos encontrar tema relacionado con la Herencia la cual
tiene ejemplos relacionados con la herencia.
8.Autor Daniel Rodríguez Herrera, “Tutorial Introducción a

Java”,”Polimorfismo” [en línea], [Act.], Disponible en Internet
http://www.programacion.com/java/tutorial/intjava/9/
[Consulta:7/11/2007]
En esta página podemos encontrar una definición de concepto de
polimorfismo, en cuanto a cambio de forma, se puede extender a los
métodos. Java permite que varios métodos dentro de una clase se llamen
igual, siempre y cuando su lista de parámetros sea distinta. Además
podemos encontrar ejemplos de polimorfismo.
9.Autor desconocido, “mozilla developer center beta1” ,”Guia JavaScript

1.5:El ejemplo Employee: Creando la Jerarquía” [en línea] [Act. 12:26, 28
may 2007] Disponible en Internet

http://developer.mozilla.org/es/docs/Gu%C3%ADa_JavaScript_1.5:El_ejemp
lo_Employee:Creando_la_jerarqu%C3%ADa [Consulta:7/11/2007]
En esta página podemos encontrar ejemplos de Jerarquía. Y se nos explica
como podemos implementar la jerarquía. Además muestra como utilizar
definiciones muy simples (y comparativamente inflexibles) para demostrar
como obtener la herencia para trabajar.
10.Autor Antonio Bel Puchol , “Apuntes Lenguaje Java” [en línea] ,[Act,
17, junio, 2001], disponible en Internet,
http://www.arrakis.es/~abelp/ApuntesJava/indice.htm [consulta
2/11/2007]
Esta pagina es de gran utilidad ya que en ella podemos encontrar apuntes
del lenguaje Java son el guión estructurado de un curso de Introducción al
Lenguaje Java, pretenden proporcionar una aproximación progresiva,
partiendo de lo más elemental e introduciendo los conceptos
ordenadamente.
En esta web podemos encontrar términos como los son: clases, Interfaces,
herencia, control de flujo, tipos de datos, etc.

2. GLOSARIO DE TÉ RMINOS
Jerarquía:
Es el orden de los elementos de una serie según su valor. Es la disposición
de personas, animales o cosas, en orden ascendente o descendente, según
criterios de clase, poder, oficio, categoría, autoridad o cualquier otro asunto
que conduzca a un sistema de clasificación. En el mundo de los animales es
la estructura social más frecuente, ya que establece un orden de dominación:
la superioridad de un animal sobre los demás suele ser resultado de
relaciones agresivas.
Interfaz:
Es una lista de acciones que puede llevar a cabo un determinado objeto. Se
declaran en una clase abstracta los métodos que se van a utilizar, pero sin su
implementación o código.
Herencia:
Se entiende por herencia cuando una clase hereda arribitos y métodos de
otra clase llamada superclase. Es decir que además de poder utilizar sus
propios métodos y atributos, ella puede utilizar los de la clase padre.

La herencia permite que se puedan definir nuevas clases basadas en clases
existentes, lo cual facilita re-utilizar código previamente desarrollado.
Se puede construir una clase a partir de otra mediante el mecanismo de la
herencia.
Clase Abstracta:
Una clase abstracta es una clase que tiene al menos un método abstracto.
Los métodos y clases abstractas no proporcionan implementación (código).
Super Clase:
La superclase es aquella clase llamada padre, de la cual otras clases o
subclases heredan o pueden usar sus atributos y métodos.
Polimorfismo:
Varios métodos pero de diferentes clases, tienen el mismo nombre, pero
realizan una tarea diferente.
Sobrecarga:
Consiste en que varios métodos dentro de una clase se llamen igual,
siempre y cuando su lista de parámetros sea distinta.

Encapsulamiento:
La base para el encapsulado de Java es el concepto de clase. Una clase
representa una abstracción de un conjunto de objetos que tienen el mismo
comportamiento y la misma estructura. Un objeto es entonces una instancia
de una clase dada.
Las estructuras de datos de una clase se definen en base a un conjunto de
variables las cuales se denominan "variables de la instancia". Finalmente, un
método es la representación de las acciones del objeto. Así pues, las
estructuras y los métodos de una clase pueden ser privados o públicos. De
esta manera los métodos de otros objetos no pueden cambiar las variables
de objetos cuyas estructuras son privadas.
Subclase
Clase que hereda atributos y métodos de otra clase, llamada superclase,
además de heredar métodos, ella posee sus propios métodos y atributos.
Clase
Clase es una agrupación de datos (variables o campos) y de funciones (mé-
todos) que operan sobre esos datos.

3. EJEMPLIFICACIÓN DE CONCEPTOS
3.1 Clase abstracta
abstract class ArchivosDirectorios {
//Métodos abstractos
abstract String crear(String no);
abstract String verifica(String no);
abstract String lista(String no);
abstract void Leearchivo(String no);
}//fin de la clase abstracta
Dominio: operaciones archivos y directorios.
El ejemplo muestra una clase abstracta, que a diferencia de las clases que
estamos acostumbrados a declarar, la clase abstracta se declara
simplemente con el modificador abstract. Los métodos abstractos se
declaran también con el mismo modificador, declarando el método pero sin
implementarlo (sin código).
Luego para que una clase pueda implementar los métodos de la clase
abstracta se le debe colocar el modificador extends, y a los métodos de
esta clase se le debe implementar el código.
Ejemplo:
import javax.swing.*;
import java.text.*;
import java.lang.String.*;
import java.io.*;
class OperacionesArchivos extends ArchivosDirectorios {

public String crear(String nombre) {
<código>
}
public String verifica(String nombre){
<código>
}
public String lista(String nombre) {
<código>
}
public void Leearchivo(String nombre){
<código>
}
Para poder crear un objeto de una clase abstracta se debe hacer lo siguiente:
ArchivosDirectorios archivos = new OperacionesArchivos(); ya que una clase
abstracta no puede ser instancia da porque no tiene implementados sus
métodos.
3.2 Interfaz
import java.util.*;
interface ArchivosDirectorios {
String crear(String no);

String verifica(String no);
String lista(String no);
void Leearchivo(String no);
}
Dominio: operaciones archivos y directorios.
En este ejemplo se muestra una clase con sus respectivos métodos, pero sin
la implementación de su código. Las clases que quieran utilizar el interfaz
ArchivosDirectorios utilizarán la palabra implements y proporcionarán el

código necesario para implementar los métodos que se han definido para el
interfaz.
Ejemplo:
import java.text.*;
import java.io.*;
class OperacionesArchivos implements ArchivosDirectorios {
public String crear(String nombre) {
<código>
}
public String verifica(String nombre){
<código>
}
public String lista(String nombre) {
<código>
}
public void Leearchivo(String nombre){
<código>
}
}
3.3 Sobrecarga
/*varias formas de multiplicar*/
public class OperacionesMatematicas {
public String operaciones (float a, float b) {
String resultado=” ”;
float mult=a*b;
flota div=a/b;
float sum=a+b;
float rest=a-b;
resultado=+ “Suma de dos reales: “ + sum + “resta de dos
reales: “ + rest + “Multiplicación de reales: “ +
mult + “División de reales: “ + div;
return (resultado);
}
public String operaciones ( int a, int b) {
String resultado=” ”;
int mult=a*b;
int div=a/b;
int sum=a+b;
int rest=a-b;

resultado=+ “Suma de dos enteros: “ + sum + “resta de dos
enteros: “ + rest + “Multiplicación de
enteros: “+ mult + “División de enteros: “ + div;
return (resultado}
}
public class Principal{
public static void main(String[] args) {
float x = 1;
float y = 2;
int v = 3;
int w = 5;
OperacionesMatematicas om=new OperacionesMatematicas();
System.out.println (om.multiplicacion(x,y));
System.out.println (om.multiplicacion(v,w));
}
}
Dominio: Operaciones matemáticas.
En este ejemplo explicamos la sobrecarga, que consiste en: que varios
métodos dentro de una clase se llamen igual, siempre y cuando su lista de
parámetros sea distinta.
La clase OperacionesMatematicas contiene dos métodos con el mismo
nombre (multiplicación), pero un método con parámetros reales y el otro
método con parámetros enteros. En el momento que se llama a uno de estos
metidos desde la clase principal, dependerá de que tipo de parámetros
estemos pasando, si detecta que los parámetros son reales, se ubica en el
método de la clase OperacionesMatematicas que contenga este tipo de
parámetros.

3.4 Herencia y Superclase
public class Padre
{
public void metodo1(double a, double b)
{
System.out.println("Clase padre, Operaciones con números
reales" + " " + "Suma: " + a+b + " " +
"Resta: " + a-b + “ ” + "Multiplicación: " + a*b +
" " + "División: " + a/b);
}
}
public class Hijo extends Padre
{
public void metodo2 (int a, int b)
{
System.out.println("Clase hijo, Operaciones con números
enteros " + " " + "Suma: " + a+b + " " +
"Resta: " + a-b + “ ” + "Multiplicación: " + a*b +
" " + "División: " + a/b);
}
}
public static void main(String[] args)
{
Hijo h = new Hijo();
h.metodo2(10,5);
h.metodo1(10.5,5.5);
}
}
Dominio: Operaciones matemáticas.
En este ejemplo se observa que la clase hijo contiene el modificador extends
de padre, esto quiere decir que la clase hijo a heredado el método de la clase
padre, es decir, la clase padre tiene un método que es metodo1, la clase hijo
tiene además del método metodo2 que es de ella, al método metodo1 , que
es el que heredo de la clase padre.

Al crear el objeto en la clase principal, observamos que se puede acceder al
método de la clase Hijo, y al método heredado de la clase padre, utilizando el
mismo objeto.
Al igual que la herencia, en este pequeño ejemplo, también se implementa
Superclase: Cuando una clase hereda atributos y métodos de otra clase, a
esta se le llama subclase, en cambio a la clase de la cual se ha heredado se
le llama superclase.
La subclase, que en este caso es class Hijo, además de haber heredado el
método de la clase padre class Padre, también tiene su propio método.
3.5 Polimorfismo
public class Perro

{
public void descripcion (String animal)
{
System.out.println(animal + " " + "caracteristicas:
mamifero, 4 patas, domestico");
}
}
public class Buitre
{
{
ave, tiene plumas, no domestico,
carroñero");
}
}
public class Piton

{

{
reptil,depredador, no domestico");
}
}
public class Tiburon
{
{
Anfibio, depredador, no domestico");
}
}

public static void main(String[] args)
{
Perro p=new Perro();
p.descripcion("perro");
Buitre b=new Buitre();
b.descripcion("buitre");
Tiburon t=new Tiburon();
t.descripcion("tiburon");
Piton pt=new Piton();
pt.descripcion("piton");
}
}
Dominio: Animales.
El concepto de polimorfismo se refiere a tener varias clases, las cuales tienen
métodos con el mismo nombre pero cada método tiene un proceso diferente.
En este caso se tienen 4 clases las cuales contienen un método y cada
método tiene el mismo nombre pero diferentes procesos, el cual devuelve
las características de algunos animales, pero mediante la creación de un
objeto para cada clase, se pueden acceder a sus métodos,
independientemente que tengan el mismo nombre.

4. PRESENTACIÓN DE UNA APLICACIÓN EJECUTABLE
4.1 Descripción del Dominio:
Nuestro dominio se trata de un almacén en el cual se tiene n cantidad de
empleado los cuales tenemos almacenados en un archivo con sus
respectivos nombre, código y salarios, cuando el empleado atiende a un
cliente, el empleado obtiene una comisión dependiendo de la cantidad que
compre el cliente, dicha comisión se le incrementa en el salario.

4.2 Descripción de las clases
CLASES ATRIBUTOS COMPORTAMIENTO

Principal El método de esta clase es el Main en
el cual se llama a las otras clases
dependiendo su orden jerárquico.
* String msnj: Los métodos de esta clase serian los

Captura los datos siguientes:
class Capturaimp introducido por el * String datos( String me)
usuario. Datos que se piden
• El código del de empleado.
• El precio del producto a comprar.
* void imprimir( String mensj)

Despliega por pantalla y consola los
datos solicitados. Dichos datos son
pasados como parámetros mediante
la clase principal.
En esta encontramos las interfaz de
abstract class los métodos abstractos aplicados a
Proyect las solución del problema
*abstract String cliente( double
compra);
* abstract String vendedor( double
venta, String cod);
* abstract String vendedor();
class Almacen Esta conformada por tres método: se
extends Proyect calcula el descuento, se calcula la
comisión, se despliega la lista de los
En este clase se

realiza una empleados:
sobrecarga de
métodos ya que * String cliente( double compra)
se utilizan dos Este método tiene como principal
métodos con el
mismo nombre función calcular el descuento que se
pero funciones le realiza al cliente dependiendo del
diferentes
monto que ha comprado, en total se
realizan tres descuentos.
* String vendedor( double
venta, String cod)
En este método se le calcula la
comisión del empleado, dependiendo
de la compra realizada por el usuario.
Dicha comisión se le aumenta al
salario.
* String vendedor()
Este método se utiliza para listar a
todos los empleados que se
encuentran en el archivo (pero sin la
comisión).
CLASES ATRIBUTOS COMPORTAMIENTO

class Compra Esta clase esta conformada por un
extends Almacen método.
* public double comprar()
Este método tiene como función
principal calcular la suma de todos
los artículos comprados por el

cliente.
Este método tienes un objeto de la
clase Capturaimp que llama al
método datos para introducir el
precio del articulo, además se nos
presenta una opción en la cual
escogemos si deseamos seguir
procesando datos. Para calcularle su
valor.
class Gerente * public String vendedor()
extends Almacen este método se aplica la super clase
mediante el super el cual es un
objeto que se utiliza para invocar
métodos de la clase padre

4.3 Clases involucradas en el programa
Clase Principal
abstract class Clase
class Almacen extends
class Compra extends class Gerente extends

4.4 Código fuente:
/* Clase principal: encargada de realizar el llamado a otras clases,

dependiendo del orden jerárquico */
import java.text.*;
class Principal{
public static void main(String[] args) {
Capturaimp cpt2=new Capturaimp();
String m="Introduzca el codigo del vendedor: ";
String cod=cpt2.datos(m);
Compra cpr=new Compra();

double c=cpr.comprar();
/* Con el objeto cpr, que es de la clase compra, se puede acceder a los

métodos de la clase almacén, esto se puede hacer porque la clase Compra
es hija
String de la clase almacén*/
mens1=cpr.cliente(c);
String aument=cpr.vendedor(c,cod);
String mens2="La comisión del empleado en esta venta fue de:"+" " + aument;
cpt2.imprimir(mens1);
Gerente grt=new Gerente();

String gernt="Estos son los datos de los empleados: " + "\n";
String mens3=gernt + grt.vendedor();

}
}

// Clase Capturaimp
/* Esta clase permite la captura y la salida de datos devuelve a la clase
principal la información ingresada y recibe resultados para imprimirlos */
import java.text.*;
class Capturaimp {
private String msnj;
public Capturaimp(){
}
public String datos(String me){

msnj= JOptionPane.showInputDialog(null,me );
return(msnj);
}
public void imprimir(String mensj)//Método para imprimir
{
JOptionPane.showMessageDialog(null,mensj);
System.out.println(mensj);
}
}
///Clase
abstract class Proyect {
//Métodos abstractos
abstract String cliente(double compra);

abstract String vendedor(double venta,String cod);
abstract String vendedor();
}

/*Clase almacén: clase padre, que se extiende de la clase abstracta. Esta clase
se encarga de efectuar un descuento a un cliente, dependiendo de la compra
que se halla realizado, también dependiendo de esa compra se le realizara al
vendedor un aumento en su sueldo (comisión por venta); además se puede
consultar al archivo de los empleados o vendedores el cual muestra: nombre
del empleado, el código del empleado, y su salario, pero el salario base (sin el
incremento).
En esta clase se aplica la sobrecarga, ya que cuenta con dos métodos con el
import java.io.*;
import java.text.*;
import java.lang.Double;
/*Método cliente: recibe la suma de la compra efectuada. Se encarga de

realizar el descuento al cliente dependiendo del total en compra*/
class Almacen extends Proyect {
public String cliente(double compra){
double desc=0;
double desc1=0;
String resp="";
//condiciones para verificar compra
if (compra>=25.00 && compra< 50.00)
{
desc=compra*.05;
desc1=compra-(compra*.05);

}
else
{
if(compra>=50 && compra < 150)
{
desc=compra*0.2;
desc1=compra-(compra*0.2);
}
else
{
if (compra>=150)
{
desc=compra*0.25;
desc1=compra-(compra*.25);
}
else
desc1=0.0;
}
}
resp="La suma total de la compra fue de : " + compra + "\n" + "El descuento fue de: " +
desc + "\n" + "El precio a pagar es de : " + desc1;
return(resp);
/*Método vendedor: recibe venta realizada, código del vendedor. Se encarga

de brindarle una comisión al vendedor, dependiendo del total de la venta
public String vendedor(double venta,String cod){
String archivoName="vendedor.txt"; //nombre del archivo que contiene a los

vendedores
double aumento1=0;

double aumento=0;
double sala=0;
String result=" ";
try {
FileReader arch1 = new FileReader(archivoName);
BufferedReader in = new BufferedReader(arch1);
String s = new String();

boolean op=false;
while(((s=in.readLine())!= null) && (op==false)){

String cd=s.substring(17,19);
if(cd.startsWith(cod)) // se compara si el código del empleado

existe en el archivo
{
op=true;
String sal=s.substring(20,23);
sala=Double.parseDouble(sal); // convertir datos del archivo a
double (salario)
//condiciones para verificar comisión
if (venta>=25.00 && venta< 50)
{
aumento1=20;
aumento=sala+20;
}
else
{
if(venta>=25 && venta< 150)
{
aumento1=30;

aumento=sala+30;
}
else
{
if (venta>=150)
{
aumento1=50;
aumento=sala+50;
}
else
aumento=0;
}
}
}
}
try {
in.close();
}
catch ( IOException e )
{
result+="El archivo no se pudo cerrar correctamente";
}
}
catch (Exception e)
{
result +="El archivo no se pudo cerrar correctamente";
}
result= aumento1 + "\n" + "El salario del empleado es: " + sala + "\n" + "El nuevo
salario :" + aumento;
return(result);

}
/*Método vendedor: encargado de desplegar los datos de los empleados que
public String vendedor(){
String archivoName="vendedor.txt";
double aumento=0;
String result=" ";
try {
FileReader arch1 = new FileReader(archivoName);
BufferedReader in = new BufferedReader(arch1);
String s = new String();
while((s=in.readLine())!= null)
result +=s + "\n";
try {
in.close();
}
catch ( IOException e )
{
result+="El archivo no se pudo cerrar correctamente";
}
}
catch (Exception e)
{
result +="El archivo no se pudo cerrar correctamente";
}
return(result);
}
}

/* clase Compra: clase hija de la clase almacén. En clase se encarga de realizar la
suma total de una compra efectuada */
import java.io.*;
import java.text.*;
class Compra extends Almacen{
public Compra(){
}
/*Método comprar: encargado de calcular la compra total que se efectuó */
public double comprar(){
Capturaimp cpt=new Capturaimp();
int op=1;
double suma=0;
double precio=0;
String opc="";
while(op==1)
{
//llamar a acapturaimp
String preci="Introduzca el precio del articulo: ";
String prec=cpt.datos(preci);
precio=Double.parseDouble(prec);
suma=suma+precio;
opc= JOptionPane.showInputDialog(null, "1: si hay otro articulo a comprar,"+
"\n" + "0: si no hay mas ariculos a comprar");
op=Integer.parseInt(opc);
}
return(suma);
}
}

/*Clase Gerente: se deriva de la clase padre Almacén. Esta clase se dedica a
llamar al método vendedor de Almacén para desplegar los datos del archivo.
En esta clase se aplica el se cuenta con un método que tiene el mismo
import java.io.*;
import java.text.*;
import java.lang.Double;
class Gerente extends Almacen {
// Método vendedor: mediante este método se llama al método vendedor de la

clase padre para desalegrar los datos de los empleados
public String vendedor(){

String cnst=super.vendedor();
return (cnst);
}
}

4.5 Ejecución del Programa
En esta pantalla se nos pide que introduzcamos el número de

código del empleado, dicho código los encontramos en un archivo
donde encontramos los código de los empleados con sus
respectivos salarios.
Después de haber introducido el código de ese empleado a el se

le van a calcular la comisión que ganara por cada venta
realizada.
Esta pantalla es para introducir el o los precios de los

artículos comprados por los clientes
En esta parte se nos presenta la opción de escoger si deseamos

seguir procesando más artículos o no.
En este caso decidimos procesar otro artículo.

Volvemos a introducir el valor del artículo.
Se nos vuelve a preguntar si deseamos seguir procesando más

articulo en este caso decidimos escoger la opción cero (0), la
cual no procesa mas artículos
En esta pantalla se nos presenta la suma de la cantidad de

artículos procesados, el descuento que se le hace a la compra, y
el monto total a pagar.
Aquí podemos observar que se nos presenta la comisión que gano

el empleado por haber atendido a dicho cliente.
Además se presenta el salario del empleado, al cual se le
incrementa la comisión obtenida.

Bueno en esta parte se lista todos los empleados que tenemos en
el archivo cada uno con su salario; “este salario es el original
sin el incremento de la comisión”

5. Diagrama UML
abstract class Proyect
abstract String cliente(double compra);

abstract String vendedor(double venta,String
cod)
class Almacen extends Proyect
String cliente(double compra)

String vendedor(double venta,String cod)
String vendedor()
class Compra extends Almacen class Gerente extends Almacen
public double comprar() public String vendedor()
class Capturaimp
class Principal String msnj
String datos(String me)

main(String[] args)
void imprimir(String

35
6. Reflexión sobre el trabajo en equipo
6.1. Cómo fue la labor de los integrantes
Para la confección de este proyecto la labor de cada integrante
principalmente fue la de realizar la búsqueda en Internet de los temas
relacionado con el proyecto, temas de los cuales teníamos que buscar
ejemplos y ayudarnos mutuamente ambos para poder identificar los errores
y dudas que teníamos y ya identificado los errores procedimos a la
confección del problema ejecutable.
Como en otros laboratorios y proyectos, siempre hay buena comunicación, se
analiza, investiga, se estudia de manera individual, para luego reunirnos,
presentar lo que cada uno investigo, salir de dudas entre ambos, reunir
información y ayudarnos, en caso de que alguno no haya entendido algo;
cada uno presenta sus ideas, la forma de cómo resolver el problema, para
luego ponernos de acuerdo y empezar a trabajar.
6.2. Metodología propuesta para el desarrollo de este proyecto
•Búsqueda en Internet.
•Recolección de lo investigado.

30
•Preparar cada ejemplificación de los temas.
•Elaboración del problema.

31
7. Evaluación individual de la experiencia
Roman González:
Conocimientos previos: en cuanto a los conocimientos previos, fue necesario leer

sobre los conceptos aplicados en este tema, para analizarlos , entenderlos y luego
aplicarlos en este laboratorio.Tambien fueron necesarios aplicar los conocimientos que
hemos estado adquiriendo en el desarrollo de este curso.
Nuevos conocimientos: Entre los nuevos conocimientos adquiridos, se encuentran

conceptos como: herencia, polimorfismo, clase abstracta, etc. al igual que su
implementación mediante los ejemplos presentados.
También entre estos conocimientos, se encuentra el de cómo puedo hacer uso de los
métodos y atributos de una clase utilizándolos en otra clase, todo mediante la herencia
y superclase.
Dificultades: La dificultad mas grande fue la de implementar en un problema todos los

conceptos que se estudiaron. Pienso que estamos acostumbrados es a resolver un
problema ya dado, y por eso se nos hizo difícil crear uno e implementar todo lo
aprendido. En un principio no sabíamos por donde empezar, a que área se iba a
implementar este problema. Luego cuando más o menos teníamos el tema, queríamos
que el problema resolviera muchas cosas, y entre mas ideas surgían, salían más
clases y mas métodos, complicándonos así un poco, de repente eso nos hizo la tarea
un poco difícil, queríamos hacer muchas cosas. Sentíamos que estábamos forzando al
problema a implementar los conceptos tratados en este laboratorio. Al final mi
compañera y yo resolvimos uno, que de repente se puede ampliar un poco mas, pero
decidimos dejarlo fácil, pero tratando de que implemente los conceptos estudiados.
A pesar de que fue difícil, la experiencia fue agradable, pienso que de esta forma se
aprende; leyendo, analizando, entendiendo, ejemplificando lo aprendido y creando
problemas y sus soluciones.

32
Yorisbeth Calles
Conocimientos previos: Los conocimientos previos que necesite para este laboratorio
fueron conceptos y temas que estamos tratando en este curso, conceptos como:
clases, métodos, encapsulamiento, entre otros. Al igual que los conceptos que se
aplicaron en este laboratorio, ya que se tuvo que investigar y estudiar previo a la
realización de este trabajo.
Nuevos conocimientos: Entre los nuevos conocimientos que adquirí, están, lo de

como hacer referencias a recursos Web; aprendí que para hacer una referencia a un
sitio Web, existen varios formatos, que llevan una serie de pasos; Además adquirí
conocimientos en temas como la herencia y jerarquía en java, y todo lo relacionado a
estos conceptos como superclase, sobrecarga, polimorfismo, etc.
Dificultades: La dificultad que tuvimos en este laboratorio fue la de crear un problema,

que aplicara todos los conceptos investigados. Encontramos que es difícil crear un
problema, y no es tan fácil implementar una herencia, un polimorfismo, una sobrecarga
o una superclase en un problema que no lo requiera, no es aplicarlos por aplicar, el
problema lo debe requerir y hay que saber cuando utilizar o implementar uno de estos
conceptos tratados en este tema.

33

Proyecto 3

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Proyecto 3

Cargado por

Copyright:

Formatos disponibles

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

CALLES YORISBETH 9-720 -2373

En este proyecto que presentaremos a continuación trata de la Herencia y

la Jerarquía, en los cuales utilizamos fuentes de información relacionados con

herencia, jerarquía, polimorfismo, clase abstracta, sobre carga, etc. Adicional

presentamos un glosario de términos referentes a los temas tratados en el

proyecto, y finalizamos el proyecto con un programa ejecutable en java

donde implementamos los temas utilizados en el proyecto.

En esta página encontramos el concepto y ejemplos de interfaz donde

podemos decir que Un interface es una colección de declaraciones de

métodos (sin definirlos) y también puede incluir constantes.

También podemos encontrar:

interface es simplemente una lista de métodos no implementados,

además puede incluir la declaración de constantes. Una clase abstracta

puede incluir métodos implementados y no implementados o abstractos,

miembros dato constantes y otros no constantes.

•Los interfaces y el polimorfismo

2.Autor desconocido, Tutorial de JAVA, “Interfaces” [en línea], {Act. lunes,

En este tutorial podemos encontrar el concepto de Interfaz, como:

La definición de un interfaz es semejante a la de una clase. La definición de

Elaborado por: Calles Yorisbeth y González Roman 1

La declaración de interfaz puede tener dos componentes adicionales, el

especificador de acceso public y la lista de superinterfaces.

Una clase puede implementar más de un interfaz, incluyendo varios nombres

de interfaces separados por comas.

Además en esta web podemos encontrar la Herencia múltiple.

3.Autor desconocido, Interfaz, arreglo y polimorfismo [en línea], [Act. ]

donde además encontramos ejemplos de mucha utilidad los cuales nos

sirvieron para tomarlo como ejemplos para poder resolver dudas.

4.Autor desconocido,”Métodos y clases abstractas” [en línea ] [Act]

Un método abstracto es un método que declara una funcionalidad que debe

ser implementada en todas las clases derivadas, en que se vaya a utilizar. En

esta página además de su definición podemos encontrar ejemplos de cómo

utilizar la clase abstracta.

Elaborado por: Calles Yorisbeth y González Roman 2

En esta página podemos encontrar información sobre la Herencia donde

podemos decir que la Herencia es uno de los mecanismos de la

otra, llamada entonces superclase, de manera que extiende su funcionalidad.

También podemos encontrar ejemplos de herencia, podemos decir que hay

dos tipos de herencia que es la herencia simple y la herencia múltiple.

6.Autor desconocido,” Subclases y Herencia” [en línea], [Act.] Disponible

En esta página podemos encontrar temas relacionados con subclases, je-

existir entre ellos, y aclarar lo que se puedes y no se debe hacer.

Elaborado por: Calles Yorisbeth y González Roman 3

En esta página podemos encontrar tema relacionado con la Herencia la cual

tiene ejemplos relacionados con la herencia.

8.Autor Daniel Rodríguez Herrera, “Tutorial Introducción a

En esta página podemos encontrar una definición de concepto de

polimorfismo, en cuanto a cambio de forma, se puede extender a los

igual, siempre y cuando su lista de parámetros sea distinta. Además

podemos encontrar ejemplos de polimorfismo.

9.Autor desconocido, “mozilla developer center beta1” ,”Guia JavaScript

Elaborado por: Calles Yorisbeth y González Roman 4

como podemos implementar la jerarquía. Además muestra como utilizar

definiciones muy simples (y comparativamente inflexibles) para demostrar

como obtener la herencia para trabajar.

Esta pagina es de gran utilidad ya que en ella podemos encontrar apuntes

del lenguaje Java son el guión estructurado de un curso de Introducción al

Lenguaje Java, pretenden proporcionar una aproximación progresiva,

partiendo de lo más elemental e introduciendo los conceptos

herencia, control de flujo, tipos de datos, etc.