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
2 Clase subclase
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
class subclase
Métodos extends TodoFlujo

class Lectura Atributos

suma_saldos
Atributos suma_depositos
Información sum_tranc_final
k sum_ret_fin
Métodos suma_retiros
error() sum_dep_fin
nombre() line
salida() aux
escribir() dinero
split() Métodos
length split()
lecarchivo

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