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

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 [Consulta: 6 de noviembre 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. Elaborado por: Calles Yorisbeth y González Roman

2

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, jerarquí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.

Elaborado por: Calles Yorisbeth y González Roman

3

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

Java”,”Polimorfismo”

[en

Herrera,

línea],

[Act.],

“Tutorial

Introducción

Disponible

en

a

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

Elaborado por: Calles Yorisbeth y González Roman

Internet

4

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.

Elaborado por: Calles Yorisbeth y González Roman

5

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.

Elaborado por: Calles Yorisbeth y González Roman

6

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.

Elaborado por: Calles Yorisbeth y González Roman

7

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.

Elaborado por: Calles Yorisbeth y González Roman

8

Elaborado por: Calles Yorisbeth y González Roman

9

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 import import import class

javax.swing.*; java.text.*; java.lang.String.*; java.io.*; OperacionesArchivos extends ArchivosDirectorios {

Elaborado por: Calles Yorisbeth y González Roman

10

public String crear(String nombre) { } public String verifica(String nombre){ } public String lista(String nombre) { } public void Leearchivo(String nombre){ } 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

Elaborado por: Calles Yorisbeth y González Roman

11

código necesario para implementar los métodos que se han definido para el interfaz. Ejemplo: import javax.swing.*; import java.text.*; import java.lang.String.*; import java.io.*; class OperacionesArchivos implements ArchivosDirectorios { public String crear(String nombre) { } public String verifica(String nombre){ } public String lista(String nombre) { } public void Leearchivo(String nombre){ } } 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;

Elaborado por: Calles Yorisbeth y González Roman

12

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.

Elaborado por: Calles Yorisbeth y González Roman

13

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 class Principal{ 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.

Elaborado por: Calles Yorisbeth y González Roman

14

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 { System.out.println(animal + mamifero, 4 patas, domestico"); } } public class Buitre { public void descripcion (String { System.out.println(animal + ave, tiene plumas, no domestico, carroñero"); } }

animal) "

" + "caracteristicas:

animal) "

" + "caracteristicas:

public class Piton { public void descripcion (String animal) Elaborado por: Calles Yorisbeth y González Roman

15

{ System.out.println(animal + " " + "caracteristicas: reptil,depredador, no domestico"); } } public class Tiburon { public void descripcion (String animal) { System.out.println(animal + " " + "caracteristicas: Anfibio, depredador, no domestico"); } } public class Principal{ 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.

Elaborado por: Calles Yorisbeth y González Roman

16

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.

Elaborado por: Calles Yorisbeth y González Roman

17

4.2 Descripción de las clases CLASES

ATRIBUTOS

Principal

COMPORTAMIENTO El método de esta clase es el Main en el cual se llama a las otras clases dependiendo su orden jerárquico.

class Capturaimp

* String msnj:

Los métodos de esta clase serian los

Captura los datos

siguientes:

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

En este clase se

comisión, se despliega la lista de los

Elaborado por: Calles Yorisbeth y González Roman

1

realiza una sobrecarga de métodos ya que se utilizan dos métodos con el mismo nombre pero funciones diferentes

empleados:

* String cliente( double compra) Este método tiene como principal función calcular el descuento que se le realiza al cliente dependiendo del 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

Elaborado por: Calles Yorisbeth y González Roman

comprados

por

el

1

cliente. Este método tienes un objeto de la clase

Capturaimp

método

datos

para

que llama al introducir

el

precio del articulo, además se nos presenta una escogemos

si

opción en la cual 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

Elaborado por: Calles Yorisbeth y González Roman

2

4.3 Clases involucradas en el programa

Clase Principal

abstract class

Clase

class Almacen extends

class Compra extends

class Gerente extends

Elaborado por: Calles Yorisbeth y González Roman

2

4.4 Código fuente:

/* Clase principal: encargada de realizar el llamado a otras clases, dependiendo del orden jerárquico */ import javax.swing.*; import java.text.*; import java.lang.String.*; 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 de la clase almacén*/ String mens1=cpr.cliente(c); String aument=cpr.vendedor(c,cod); String mens2="La comisión del empleado en esta venta fue de:"+" " + cpt2.imprimir(mens1); cpt2.imprimir(mens2);

aument;

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

Elaborado por: Calles Yorisbeth y González Roman

2

} }

Elaborado por: Calles Yorisbeth y González Roman

2

// 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 javax.swing.*; import java.text.*; import java.lang.String.*; 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(); } Elaborado por: Calles Yorisbeth y González Roman

2

/*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 import import import import import

java.io.*; javax.swing.*; javax.swing.*; java.text.*; java.lang.String.*; 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);

Elaborado por: Calles Yorisbeth y González Roman

2

} 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;

Elaborado por: Calles Yorisbeth y González Roman

2

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; Elaborado por: Calles Yorisbeth y González Roman

2

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); Elaborado por: Calles Yorisbeth y González Roman

2

}

/*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); } }

Elaborado por: Calles Yorisbeth y González Roman

2

/* clase Compra: clase hija de la clase almacén. En clase se encarga de realizar la suma total de una compra efectuada */ import import import import import

java.io.*; javax.swing.*; javax.swing.*; java.text.*; java.lang.String.*;

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); } } Elaborado por: Calles Yorisbeth y González Roman

3

/*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 import import import import import

java.io.*; javax.swing.*; javax.swing.*; java.text.*; java.lang.String.*; 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); } }

Elaborado por: Calles Yorisbeth y González Roman

3

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

o

precios

venta

realizada. Esta

pantalla

es

para

introducir

el

los

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.

Elaborado por: Calles Yorisbeth y González Roman

3

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.

Elaborado por: Calles Yorisbeth y González Roman

3

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”

Elaborado por: Calles Yorisbeth y González Roman

3

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 public double comprar()

class Gerente extends Almacen

public String vendedor() class Capturaimp class Principal main(String[] args)

Elaborado por: Calles Yorisbeth y González Roman

String msnj String datos(String me) void imprimir(String 3 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.

Elaborado por: Calles Yorisbeth y González Roman

3 30

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

Elaborado por: Calles Yorisbeth y González Roman

3 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.

Elaborado por: Calles Yorisbeth y González Roman

3 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.

Elaborado por: Calles Yorisbeth y González Roman

3 33