UNIVERSIDAD NACIONAL

CENTRO REGIONAL UNIVERSITARIO DE VERAGUAS

FAC. DE INFORMÁTICA ELECTRÓNICA Y COMUNICACIÓNLICENCIATURA 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

EntregaPresentar 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

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.

1 Clase principal

2 Clase lectura

3 Clase Todo Flujo

4 Clase subclase

UML

class Lectura

AtributosInformaciónk

Métodoserror()nombre()salida()escribir()split()length

class Principal

Atributosdatosarch_lecturaarch_saldoarch_depositosflujollamar

Métodosclass subclase extends TodoFlujo

Atributossuma_saldossuma_depositossum_tranc_finalsum_ret_finsuma_retirossum_dep_finlineauxdinero

Métodossplit()lecarchivo

class TodoFlujo

Atributos

IsrIn wname

MétodosTodoFlujo()TodoFlujo()TodoFlujo()

Clase PrincipalEsta clase es la que se encarga de manejar del funcionamiento del programa

Tabla que muestra los objetos que se utilizaron el programaTipo Objeto UtilidadString 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 LecturaClase de entrada y salida de datos

Tabla que muestra los objetos que se utilizaron el programaTipo Objeto UtilidadString 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 programaMétodo Utilidaderror() 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 flujoEn 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 programaMétodos Utilidad

TodoFlujo modela el flujo para archivo de texto

Clase SubclaseEn esta clase es en donde se crea los tres archivos donde estarán los datos actualizados y se procesara el archivo originalTabla que contiene los objetos que se utilizaron y su funcionamiento

Tipo objeto utilidadDouble 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 Objeto que almacena los depósitos finales que se van a escribir en el archivo de depósitos finales

String ret_fin 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<imprimir.length;i++)

dat.println(imprimir[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"+" "+"3"+" " + sum_tranc_final+",";

dep_fin= dep_fin+" "+"999999"+" "+"3"+" " + sum_dep_fin+",";

ret_fin= ret_fin+" "+"999999"+" "+"3"+" " + sum_ret_fin+",";

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 textoFileReader arch1 = new FileReader(Name);this.in = new BufferedReader(arch1);

}

public TodoFlujo()throws IOException{// lectura estadar //tecladothis.isr=new InputStreamReader(System.in);this.in = new BufferedReader(isr);

}//sobrecargamos el contructorpublic 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 clasereturn(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