Trabajo Escrito Herencia

UNIVERSIDAD NACIONAL CENTRO REGIONAL UNIVERSITARIO DE VERAGUAS FAC. DE INFORMÁTICA ELECTRÓNICA Y COMUNICACIÓN LICENCIATURA DE INGENIERÍA EN INFORMÁTICA PROGRAMACIÓN III

LABORATORIO HERENCIA FACILITADOR DIEGO SANTIMATEO ESTUDIANTES EURIS MORALES 9-726-1057 SEGUNDO SEMESTRE

FECHA DE ENTREGA NOVIEMBRE 2008

INTRODUCCIÓN El lenguaje Java permite el empleo de la herencia, característica que permite definir una clase tomando como base a otra clase ya existente. Esto es una de las bases de la reutilización de código, en lugar de copiar y pegar. La herencia se considera como un concepto fundamental en la programación orientada a objetos ya que esta puede hacer relaciones con otras clases de manera jerárquica. A continuación observara el funcionamiento de una clase y una subclase la forma en que se accede y el funcionamiento del polimorfismo.

CONTENIDO 1. Objetivos del laboratorio 2. Planteamiento del problema 3. Interfaz grafica 3.1 Archivo Original 3.2 Archivo para saldos 3.3 Archivo para depositos 3.4 Archivo para retiros 3.5 Errores 4. Archivos de texto 4.1 Archivo de datos originales 4.2 Archivo de transacciones Actualizadas 4.3 Archivo de depositos Actualizados 4.4 Archivo de retiros Actualizados 5. Esquema de funcionamiento del programa 6. UML 7. Tablas 7.1 Declaración de objetos y métodos de las clases 8. Código Fuente 9. Conclusión

OBJETIVOS

Objetivos generales:

 Comprender el

lenguaje java para llevar a cabo la programación orientada a

objetos.

Objetivos específicos:

 Comprender el manejo del concepto de Herencia y Polimorfismo.  Realizar una aplicación que pueda procesar datos de un archivo y actualizarlos en

distintos archivos de acuerdo con el tipo de cuenta especificado.

HERENCIA En la carpeta solución de parciales de Synergia encontrará la Clase TodoFlujo que encapsula la configuración de streams para teclado, archivo y URL. En este laboratorio usted debe crear una subclase de TodoFlujo que aplique polimorfismo y que permita leer un archivo de texto que contiene transacciones de cuentas de ahorro con los siguientes campos; número de cuenta, tipo de transacción y un valor que corresponde al dinero de la transacción. Si el tipo es cero, se trata del saldo anterior de la cuenta, si es uno, corresponde a un depósito y si es dos, la transacción es un retiro. El archivo está ordenado por número de cuenta y tipo de transacción, cada transacción se encuentra en una línea diferente. La subclase debe crear un nuevo archivo con los saldos actualizados, otro con los depósitos y otro con los retiros. En cada archivo el último registro debe tener tipo tres (3) con número de cuenta 9999 y el valor será la suma de todos los valores de las transacciones contenidas en él. Este es un trabajo voluntario e individual Entrega Presentar la estructura del programa (UML) con la respectiva documentación de las clases, variables de instancias y comportamiento, el código fuente y evidencia de la ejecución, con suficientes pruebas.

Los interesados sustentarán el viernes 21 de noviembre y entregarán el informe impreso.

INTERFAZ GRAFICA

Archivo Original

Interfaz grafica donde se muestra como el usuario debe introducir el nombre del archivo que se va a procesar (archivo ya confeccionado). Para este caso el nombre que tiene este archivo es datos y su extension es txt porque es un archivo de texto. Archivo para saldos

Interfaz grafica donde se muestra como el usuario debe introducir el nombre del primer archivo o el archivo que va a contener los saldos de cada una de las cuentas . Para este caso el nombre que se utilizo fue saldos, pero a diferencia del archivo de lectura este (nombre de archivo) se puede cambiar a criterio del usuario con la extension txt. Archivo para depositos

Interfaz grafica donde se muestra como el usuario debe introducir el nombre del archivo que va a contener los depositos de cada una de las cuentas . Para este caso el nombre que se utilizo fue depositos , pero a diferencia del archivo de lectura este tambien se puede cambiar a criterio del usuario .Al igual que los demas archivos este debe tener la extension txt.

Archivo para retiros

Interfaz grafica donde se muestra como el usuario debe introducir el nombre del archivo que va a contener los retiros de cada una de las cuentas . Para este caso el nombre que se utilizo fue retiros , pero a diferencia del archivo de lectura este tambien se puede cambiar a criterio del usuario. Al igual que los demas archivos este debe tener la extension txt. Errores

Interfaz grafica donde se muestra al usuario cuando introduce datos incorrectos como el nombre del archivo original o la falta de la extension del archivo

ARCHIVOS DE TEXTO Archivo de datos originales

En este archivo se muestra los datos que se van a procesar(actualizarlos en otros archivos ) Archivo de transacciones Actualizadas

En este archivo se muestra los saldos actualizados para cada cuenta En la cuenta 99999 está la suma de los saldos de las cuentas

Archivo de depósitos actualizados

Este archivo muestra la suma de los depósitos. Hay dos cuentas que tienen depósitos 0.0 porque no hubo depósitos

Archivo de retiros actualizados

En este archivo se muestran los retiros actualizados pero solo los retiros que se puedan efectuar (si el saldo es mayor que los retiros) En el número de cuenta 99999 se muestra la suma de todos los retiros efectuados en cada cuenta

Esquema de funcionamiento del programa

1 Clase principal

4 Clase subclase

2 Clase lectura

3 Clase Todo Flujo

•

Clase principal: Controla la ejecución del programa

•

Clase Todo flujo: Clase que modela el flujo para archivo de texto.

•

Clase subclase: Clase que procesa el archivo que contiene los datos y crea los archivos para escribir los datos actualizados.

•

Clase Lectura: Clase de entrada y salida de datos

Nota: La clase lectura solo regresa o devuelve datos a la clase principal solo cuando entran datos al programa (nombres de los archivos) cuando la subclase invoca a la clase lectura es solo para la salida.

UML

class Principal

Atributos datos arch_lectura arch_saldo arch_depositos flujo llamar Métodos

class subclase extends TodoFlujo Atributos suma_saldos suma_depositos sum_tranc_final sum_ret_fin suma_retiros sum_dep_fin line aux dinero Métodos split() lecarchivo

class Lectura Atributos Información k Métodos error() nombre() salida() escribir() split() length

class TodoFlujo Atributos Isr In w name Métodos TodoFlujo() TodoFlujo() TodoFlujo()

Clase Principal Esta clase es la que se encarga de manejar del funcionamiento del programa Tabla que muestra los objetos que se utilizaron el programa Tipo Objeto Utilidad String arch_lectura Objeto que recibe (retorno de la clase de entrada y salida) el nombre del archivo que se va a procesar String arch_saldo Objeto que recibe el nombre del archivo que va a contener los saldos actualizados String arch_depositos Se encarga de recibir el nombre del archivo que va a contener los depósitos actualizados String arch_retiros Objeto que recibe el nombre del archivo que va a contener los retiros actualizados subclase flujo Objeto que se encarga de invocar a métodos que se encuentran en la clase subclase Nota: En la clase principal no se utilizo ningún método solo se accede a ellos

Clase Lectura Clase de entrada y salida de datos Tabla que muestra los objetos que se utilizaron el programa Tipo Objeto Utilidad String información Objeto que almacena el nombre de los archivos Int k Objeto que contiene el tipo de cuenta , este determina en que archivo se deben escribir los datos finales String datos Objeto que contiene los datos finales que se van a escribir en los archivos Tabla que muestra los Métodos que se utilizaron el programa Método Utilidad error() Método que despliega un mensaje de error cuando se introducen nombres de archivos incorrectamente nombre() Método donde se introduce el nombre del archivo que se va a procesar salida() Método donde se introducen los nombres de los archivos de salida escribir() Método donde se escribe en los tres nuevos archivos los datos finales de cada transacción

Clase Todo flujo En esta clase es en donde se prepara el archivo de lectura para su posterior utilización. Tabla que muestra los Métodos que se utilizaron el programa Métodos Utilidad TodoFlujo

modela el flujo para archivo de texto

Clase Subclase En esta clase es en donde se crea los tres archivos donde estarán los datos actualizados y se procesara el archivo original Tabla que contiene los objetos que se utilizaron y su funcionamiento Tipo objeto utilidad Double suma_saldos Se encarga de almacenar la suma de cada uno de los saldos de cada cuenta Double

suma_retiros

Objeto que almacena la suma los retiros de cada cuenta

Double

suma_depositos

Se encarga de almacenar la suma de los depósitos de cada cuenta

Double

sum_tranc_final

Objeto que almacena la suma total de las cuentas esta suma estará en otra cuenta (9999)

Double

sum_ret_fin

Se encarga de almacenar la suma total de los retiros este estará en otra cuenta (9999)

Double

sum_dep_fin

Objeto que almacena la suma total de los retiros está suma estará en la cuenta 9999

Int

tip_cuent

Objeto que contiene el tipo de cuenta ya sea un saldo anterior un deposito o un retiro (0,1,2)

int

dinero

Objeto que contiene el saldo o dinero que se encuentra en cada tipo de cuenta

String

cuenta

Objeto que almacena el numero de cuenta para todos los que existen en el archivo original

String

tra_fin

Se utilizo para almacenar los saldos finales y demás datos que corresponden al archivo de los saldos actualizados

String

dep_fin

String

ret_fin

Objeto que almacena los depósitos finales que se van a escribir en el archivo de depósitos finales Se encarga de almacenar los retiros que se van a escribir en el archivo de los retiros actualizados

Clase subclase Tabla que muestra los métodos utilizados en esta clase y su funcionamiento Objeto

Utilidad

lecarchivo

En este método es donde se procesa el archivo original y donde se crea los tres nuevos archivos

split()

Método que corta cadenas de caracteres de acuerdo con la opción que el programador le asigne

readLine()

efectúa la lectura de la cadena

CÓDIGO FUENTE DEL PROGRAMA CLASE PRINCIPAL //clase que controla toda la ejecucion del programa import java.lang.String.*; import javax.swing.*; import java.io.*; import javax.swing.JOptionPane; public class Principal{

//clase principal

public static void main(String args[])throws IOException { try{ Lectura datos= new Lectura(); String arch_lectura=datos.nombre();//invocación del método donde el usuario introduce nombre del archivo de lectura String arch_saldo = datos.salida();//invocación del método donde el usuario introduce el nombre de //archivo de escritura String arch_depositos = datos.salida();//Invocación del método donde se introduce el nombre del segundo archivo de escritura String arch_retiros = datos.salida();//Invocacion del metodo donde se introduce el nombre del tercer archivo de escritura

subclase flujo=new subclase(arch_lectura); subclase llamar=new subclase(); flujo.lecarchivo(arch_saldo,arch_depositos,arch_retiros);//método de lectura del archivo } //fin del try catch(Exception texto) //excepción cuando el dato introducido es incorrecto

{ Lectura datos9= new Lectura(); //clase de entradas y salidas de datos datos9.error();//metodo que se invoca para enviar un mensaje de error }//fin del catch }//fin del main

} //fin de la clase

CLASE LECTURA

//clase que captura la entrada y salida de datos al programa import javax.swing.JOptionPane; import java.io.*; import java.util.*; public class

Lectura//clase de entrada y salida de datos

{

/////metodo que despliega error al introducir datos equivocados//////////// public void

error()

{ JOptionPane.showMessageDialog(null,"Error de captura","Informacion No Valida",JOptionPane.ERROR_MESSAGE);

} ///////Metodo Donde se introduce el nombre del archivo txt////////

public

String nombre()

{ String informacion= JOptionPane.showInputDialog(null,"Introduzca el Nombre del archivo de lectura",JOptionPane.QUESTION_MESSAGE); return(informacion); } //////metodo donde se introduce el nombre de los archivos que se van a crear public

String salida()

{ String informacion= JOptionPane.showInputDialog(null,"Introduzca el Nombre de archivo de escritura ",JOptionPane.QUESTION_MESSAGE); return(informacion); } public void escribir(PrintWriter dat,String datos,int k)//metodo para escribir en los archivos { if(k==0){dat.println("

"+" ");

dat.println("Archivo de transacciones actualizadas ");dat.println(" "+" "); dat.println("...................................................." ); dat.println(" Cuenta"+"

"+"Tip De Cuenta"+"

"+" Saldos");

dat.println("...................................................." ); dat.println("

");}

else{ if(k==1){dat.println("

");

dat.println("Archivo de depositos actualizados ");

");dat.println("

dat.println("...................................................." ); dat.println(" Cuenta"+"

"+"Tip De Cuenta"+"

"+" depositos");

dat.println("...................................................." ); dat.println(" else

");}

{dat.println("

");

dat.println("Archivo de retiros actualizadoss ");

");dat.println("

dat.println("...................................................." ); dat.println(" Cuenta"+"

"+"Tip De Cuenta"+"

"+" Retiros");

dat.println("...................................................." ); dat.println(" ");}}

String[] imprimir=datos.split(","); for(int i=0;i
CLASE SUBCLASE //clase donde se procesa el archivo de escritura y se crean los nuevos archivos //donde se actualizan las cuentas de acuerdo al saldo, depositos y retiros. import java.io.*; import javax.swing.*; import java.net.*; public class subclase extends TodoFlujo{ public subclase()throws IOException{} public subclase(String arch)throws IOException{//modela el flujo para archivo de texto super(arch); } public void lecarchivo(String saldo,String depositos,String retiros)throws Exception { String cuenta="xxx";String tra_fin="";String dep_fin=""; String ret_fin="";

PrintWriter sald = new PrintWriter(saldo);//se crea el arrchivo donde se almacenaran las trasnsacciones actualizadas PrintWriter dep = new PrintWriter(depositos);//se crea el archivo donde se almacenaran los depositos PrintWriter ret = new PrintWriter(retiros);//se crea el archivo para guardar los retiros ya actualizados

try{ Double suma_saldos = 0.0; Double suma_retiros=0.0; Double suma_depositos=0.0;Double sum_tranc_final=0.0;Double sum_ret_fin=0.0;Double sum_dep_fin=0.0; Double dinero=0.0;//declaracion de los objetos a utilizar

int aux=1; String line=""; while ((line = this.in.readLine()) != null) { String[] datos = line.split("

");//se corta los datos del archivo

int tip_cuent=Integer.parseInt(datos[1]);//se transforma a entero el tipo de transaccion(0,1,2) dinero =Double.parseDouble(datos[2]);//se trasforma el dinero a double de cada cuenta

if(tip_cuent==0) {

//si el tipo de cuenta es 0 entonces

if(suma_saldos!=0.0) { sum_tranc_final=sum_tranc_final+suma_saldos;//se suman los saldos de las cuentas sum_ret_fin=sum_ret_fin+suma_retiros;//se suman los retiros de las cuentas l sum_dep_fin=sum_dep_fin+suma_depositos;//se suman los depósitos de las cuentas

tra_fin = tra_fin +" "+cuenta+" "+"0"+" "+suma_saldos+",";//se almacenan los datos finales de los saldos dep_fin = dep_fin +" "+cuenta+" "+"1"+" "+suma_depositos+",";//se almacenan los datos finales de los depósitos ret_fin = ret_fin +" "+cuenta+" "+"2"+" "+suma_retiros+",";//se almacenan los datos finales de los retiros suma_retiros=0.0;//se inicializa la suma de los retiros suma_depositos=0.0;//se inicializa la suma de los depósitos } cuenta=datos[0];//se almacena el numero de cuenta suma_saldos=dinero;//se almacena el dinero que hay en cada cuenta

} //fin de la condicion

if(tip_cuent==1)//si el tipo de cuenta es 1 entonces {suma_saldos= suma_saldos + dinero;//se suman los saldos y suma_depositos= suma_depositos+dinero;}//se suman los depositos

else{ if((tip_cuent==2)&&(suma_saldos>dinero))//si el tipo de cuenta es 2 entonces {

suma_saldos =suma_saldos

- dinero;//se resta los retiros al saldo y

suma_retiros=suma_retiros+dinero;//se suman los retiros } }

}//fin del while tra_fin = tra_fin +" "+cuenta+" "+"0"+" "+suma_saldos+",";//se almacenan los datos finales de los saldos para la ultima cuenta dep_fin = dep_fin +" "+cuenta+" "+"1"+" "+suma_depositos+",";//se almacenan los datos finales de los depositos para la ultima cuenta ret_fin = ret_fin +" "+cuenta+" "+"2"+" "+suma_retiros+",";//se almacenan los datos finales de los retiros para la ultima cuenta //se suman los saldos depsositos y retiros para la ultima cuenta sum_tranc_final=sum_tranc_final+ suma_saldos; sum_ret_fin=sum_ret_fin+suma_retiros; sum_dep_fin=sum_dep_fin+suma_depositos; //se almacena el ultimo tipo de cuenta con la suma de los saldos, retiros y depossitos

tra_fin =tra_fin+" "+"999999"+" sum_tranc_final+","; dep_fin= dep_fin+" "+"999999"+" sum_dep_fin+","; ret_fin= ret_fin+" "+"999999"+" sum_ret_fin+",";

"+"3"+" "+"3"+" "+"3"+"

" + " + " +

Lectura dato= new Lectura(); dato.escribir(sald,tra_fin,0);//se invoca el metodo de salida para el primer archivo (saldos) dato.escribir(dep,dep_fin,1);//se invoca el metodo de salida para el segundo archivo (depositos) dato.escribir(ret,ret_fin,2);//se invoca el metodo de salida para el tercer archivo (retiros) in.close();//cierre del archivo de lectura (archivo original) sald.close();//cierre del archivo de escritura (saldos) dep.close();//cierre del archivo de escritura (depósitos) ret.close();//cierre del archivo de escritura (retiros) }

catch ( IOException e ){} finally {

// cuando termina el try se realize finally

} //se retorna la materia buscada

}//fin de la lectura de archivo }

CLASE TODO FLUJO import java.io.*; import javax.swing.*; import java.net.*; public class TodoFlujo{

public BufferedReader in; private InputStreamReader isr; public TodoFlujo(String Name)throws IOException{//modela el flujo para archivo de texto FileReader arch1 = new FileReader(Name); this.in = new BufferedReader(arch1); } public TodoFlujo()throws IOException{// lectura estadar //teclado this.isr=new InputStreamReader(System.in); this.in = new BufferedReader(isr); } //sobrecargamos el contructor public TodoFlujo(int w,String Name)throws IOException{//url URL rutaservi=new URL(Name); URLConnection pag=rutaservi.openConnection(); InputStream is=pag.getInputStream(); this.isr=new InputStreamReader(is); this.in = new BufferedReader(isr); } public BufferedReader lee()throws IOException{//la lectura se hace fuera de la clase return(in); }//el "Objeto" que utilize este metodo puede leer con el metodo readLine() //recordemos que el metodo readLine() pertenece a la clase BufferedReader }//Fin de la clase

CONCLUSIÓN

En java, como ya vimos la herencia se especifica agregando la cláusula extends después del nombre de la clase. En la cláusula extends se indicara el nombre de la clase base de la cuál queremos heredar. En este lenguaje al heredar de una clase padre, heredaremos los métodos como los atributos, mientras que los constructores son utilizados, pero estos no son heredados