UNIVERSIDAD DE PANAMÁ

CENTRO REGIONAL UNIVERSITARIO DE VERAGUAS

FACULTAD DE INFORMÁTICA ELECTRÓNICA Y COMUNICACIÓN

INF.222

PROGRAMACIÓN ORIENTADA A OBJETOS

PROYECTO #4

“HERENCIA”

PROFESOR

DIEGO SANTIMATEO

ESTUDIANTE

MARÍA GONZALEZ 2-721-522

II AÑO

II SEMESTRE

2008

1
 INTRODUCIÓN
El objetivo de este laboratorio es la utilización de Herencia aplicando Polimorfismo.
Herencia, es un concepto fundamental en la programación orientada a objetos, permite relacionar
las clases de manera jerárquica.
En este laboratorio también se utiliza el concepto de encapsulación, para lograr un mejor manejo de
los métodos de cada clase.
Los invito a que lean este informe para que vean la aplicación del concepto de herencia aplicando
encapsulación.

2
 TABLA DE CONTENIDO

1) Enunciado del Problema

2) Jerarquía
3) UML
4) Documentación de las Clases
5) Documentación de los Métodos de cada Clase
6) Códigos Fuentes
7) Archivos que contiene las cuentas de los Clientes
7.1) Cuentas Bancarias
7.2) Cuentas
8) Resultados de la ejecución para las Cuentas Bancarias
9) Resultados de la ejecución para el archivo Cuentas
10) Conclusión

3
 ENUNCIADO DEL PROBLEMA

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.

4
 JERARQUIA

Clase Principal

Clase
Captura

Clase Archivo

Clase
TodoFlujo

5
 UML

CLASE TODO
FLUJO
public
BufferedReader in
private CLASE ARCHIVO
InputStreamReader
LeerArch(String dat)
isr

public
BufferedReader lee()

CLASE CAPTURA

public String Leer()

private String Mensajes()
public String Valor()

CLASE PRINCIPAL
Esta es la clase donde se hace el
llamado de las otras clases.

6
 DOCUMENTACIÓN DE LAS CLASES
CLASES FUNCIÓN
CLASE PRINCIPAL En esta clase es donde se encuentra el main, es
decir que esta clase es el padre de las demás
clases, por consiguiente encontraremos el
llamado de los métodos necesarios para la
realización del programa y cumplir con el
objetivo del laboratorio.
CLASE CAPTURA Esta clase se encarga de capturar los nombres de
los archivos tanto el archivo que se desea
trabajar y los nuevos archivos que se van a crear.
CLASE TODOFLUJO Para esta clase encontraremos métodos para la
realización del programa; un constructor que me
permite preparar mediante el BufferReader un
archivo para lectura y relacionado a esté un
método que me retorna la variable que contiene
el contenido del archivo listo para ser leído.
Otro del los métodos es el que me crea los
archivos para escritura que esta relacionado con
otro método que permite escribir en los
respectivos archivos los datos correspondiente a
cada archivo y cerrarlos.
SUBCLASE ARCHIVO Esta clase es subclase de TodoFlujo y por lo
tanto puede acceder a los métodos y
constructores de la clase TodoFlujo, a esto le
llamaremos polimorfismo.
Aquí se encontrará, aplicando polimorfismo, la
utilización de métodos y constructores de la
clase TodoFlujo, también se encontrará un
método que realiza las operaciones necesarias
para llevar a cabo el objetivo de este laboratorio.

7
 DOCUMENTACIÓN DE LOS MÉTODOS PARA CADA CLASE

CLASE PRINCIPAL

METODOS FUNCIONAMIENTO
Esta clase no contiene métodos Sin embargo aquí se encuentra el llamado de los
métodos de otras clases para la ejecución del
programa.

CLASE CAPTURA
METODO FUNCIONAMIENTO
Leer() Es donde se captura el nombre del archivo en la
cual se va a trabajar y luego lo retorna
Mensajes() En este método se captura los nombres del los
nuevos archivos que se desean crear y retorna
dichos nombres, este método es privado.
Valor() Es un método publico, la operación que realiza
este método es mediante un split separar los
nombres del archivo para luego retornarlo a la
clase padre para que este lo envié a la clase que
necesita estos datos.

8
 CLASE TODOFLUJO

METODOS FUNCIONAMIENTO
lee() Este método es publico y retorna la variable que
contiene el archivo para ser leído por el usuario.
ArchEscritura(String n) Es un método privado, su trabajo es crear los
nuevos archivos para escritura y retorna el
archivo creado.
EscribirArch(String d,String linea) Tiene dos parámetros que es el nombre del
archivo y sus respectivos datos.
Su trabajo es mediante el llamado del método
anterior, escribir los datos en los archivos y
cerrarlos dichos archivos.

SUBCLASE ARCHIVO
METODOS FUNCIONAMIENTO
LeerArch(String dat) Este es el método que realiza las operaciones
necesarias para lograr el objetivo del laboratorio.
En este método se utiliza el polimorfismo, es
decir que se utiliza los métodos de la clase
TodoFlujo para la escritura de los datos en los
archivos correspondientes.

CODIGOS FUENTES
Para el desarrollo de este proyecto se utilizó cuatro clases usando herencia, polimorfismo y
encapsulación. A continuación se presenta los códigos respectivos.
9
 CÓDIGO DE LA CLASE PRINCIPAL

import javax.swing.*;
class Principal
{
public static void main(String[] args)
{
String dat,mensaje="";
int i=0;
Captura datos= new Captura();
dat=datos.Leer();
try
{
mensaje=datos.Valor();
Archivo nom=new Archivo(dat);
nom.LeerArch(mensaje);

}
catch(Exception e)
{
}

}//fin main

}//fin principal

CÓDIGO DE LA CLASE CAPTURA

import javax.swing.*;
/*CLASE QUE CAPTURA DATOS */

1
class Captura
{
public String Leer()
{
String nombre=JOptionPane.showInputDialog("ESCRIBE EL
NOMBRE DEL ARCHIVO ");
return(nombre);
}//fin Leer

private String Mensajes()/*Construye el mensaje para indicar al usuario el

nombre de los archivos que el usuario debe introducir*/
{
String entrada="";

entrada+="Indoque el nombre del archivo para guardar los

saldos actualizados"+";";
entrada+="Indique el nombre del archivo para guardar los
depositos actualizados"+";";
entrada+="Indique el nombre del archivo para guardar los
retiros actualizados";

return(entrada);
}//fin mensaje

public String Valor() /*METODO PARA SEPARAR EL NOMBRE DE LOS

ARCHIVOS*/
{
String mensaje="",n="";
int i=0;
mensaje=Mensajes();
String men[]=mensaje.split(";");
while(i<men.length) {
n+= JOptionPane.showInputDialog(null,men[i])+":";
i++;
}
return(n);
}//fin valor
}//fin Captura

CÓDIGO DE LA CLASE TODOFLUJO

import java.io.*;
import javax.swing.*;
import java.net.*;
11
import java.lang.String;

public class TodoFlujo{

public BufferedReader in;

private InputStreamReader isr;

public TodoFlujo(String nombre)throws IOException{//modela el flujo

para archivo de texto
FileReader arch1 = new FileReader(nombre);
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 nombre)throws IOException{//url

URL rutaservi=new URL(nombre);

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

//METODO QUE CREA ARCHIVOS PARA ESCRITURA

private PrintWriter ArchEscritura(String n)throws IOException{
PrintWriter Escribir=new PrintWriter(n);
return(Escribir);
}

//METODO QUE GRAVA LOS DATOS EN EL ARCHIVO Y CIERRA EL

ARCHIVO
public void EscribirArch(String d ,String linea)throws IOException
1
 {
PrintWriter arch=ArchEscritura(d);
String[] lon=linea.split(";");//SEPARA LA TRANSACION DE CADA
CUENTA
for(int i=0;i<lon.length;i++)
arch.println(lon[i]);
arch.close();
}
}//Fin de la clase maneja Fichero

CÓDIGO DE LA SUBCLASE ARCHIVO

/*ESTE PROGRAMA LEE UN ARCHIVO DE TEXTO QUE CONTIENE

TRANSACCIONES

1
 ESTAS TRANSACCIONES SON: SALDO ANTERIOR DE LA
CUENTA,DEPÓSITOS DE LA CUENTA Y RETIROS
POR CADA TIPO DE TRANSACION CREA UN NUEVO ARCHIVO CON SUS
VALORES */
import java.lang.String;
import java.io.*;
import java.io.*;

class Archivo extends TodoFlujo

{

public Archivo() throws IOException{

}//fin constructor

public Archivo(String nombre)throws IOException

{
super(nombre); //invoca al constructor de la clase TodoFlujo
}//fin

//METODO QUE LEE UN ARCHIVO PARA REALIZAR LAS

OPERACIONES

public void LeerArch(String dat)throws IOException

{
//delcaracion de las variables
String codigo=" ",sal="",reti="",depo="";
String line = "";
Double saldos=0.00,valor=0.00;
Double dep=0.00,ret=0.00,sal_act=0.00,dep_tot=0.00,ret_tot=0.00;

String cat[]=dat.split(":");//separa los nombres de los archivos

try
{

while ((line = super.lee().readLine()) != null)//lee cada linea del archivo

{

String [] se= line.split(" ");//separa los datos de la linea

valor=Double.parseDouble(se[2]);

if(se[1].equals("0"))//verifica transacion del saldo anterior

{
if(saldos!=0.00)
{
sal_act+=saldos;//variable

1
 dep_tot+=dep;//

ret_tot+=ret;

sal+=codigo+" "+"0"+" "+saldos+";";

depo+=codigo+" "+"1"+" "+dep+";";

reti+=codigo+" "+"2"+" "+ret+";";

dep=0.00;
ret=0.00;
}//fin del if

codigo=se[0]; /* */
saldos=valor;
}//fin del if que verifiva el tipo de transacion "0"

if(se[1].equals("1"))//verifica transacion de retiro

{
dep+=valor;

saldos+=valor;

}//fin if de retiro

else
if((se[1].equals("2"))&&(saldos>valor))//verifica transacion de
deposito
{
ret+=valor;

saldos=saldos-valor;
}

}//fin wihile

sal_act+=saldos;
sal+=codigo+" "+"0"+" "+saldos+";"+"9999"+" "+"3"+" "+sal_act;

dep_tot+=dep;
depo+=codigo+" "+"1"+" "+dep+";"+"9999"+" "+"3"+" "+dep_tot;

1
 ret_tot+=ret;
reti+=codigo+" "+"2"+" "+ret+";"+"9999"+" "+"3"+" "+ret_tot;

super.EscribirArch(cat[0],sal);
super.EscribirArch(cat[1],depo);
super.EscribirArch(cat[2],reti); // invoca al metodo de la clase TodoFlujo

in.close();
}//fin del try
catch(Exception e)
{
}//fin catch

}//fin LeerArch

}//fin Archivo

ARCHIVOS QUE CONTIENE CUENTAS DEL CLIENTE CON SUS TIPOS

DE TRANSACCIONES Y SALDOS.

CUENTAS BANCARIAS
1
 CUENTAS

RESULTADO DE LA EJECUCIÓN DEL PROGRAMA PARA EL ARCHIVO

CUENTAS BANCARIAS.

1
 Escribimos el nombre del archivo que se desea trabajar.

Escribimos el nombre del archivo para los saldos actualizados.

Escribimos el nombre del archivo para los depósitos actualizados.

Se escribe el nombre del archivo para los retiros actualizados.

LOS NUEVOS ARCHIVOS CREADOS

Archivo para los saldos actualizados de cada cuenta

1
Archivo para los depósitos actualizados de cada cuenta

Archivos para los retiros actualizados para cada cuenta

1
RESULTADO DE LA EJECUCIÓN DEL PROGRAMA PARA EL ARCHIVO
CUENTAS.
2
En esta pantalla gráfica se muestra el nombre del archivo que se desea trabajar.

Esta pantalla gráfica se introduce el nombre del archivo para los saldos
actualizados.

Se escribe el nombre del archivo para los depósitos actualizados.

Con esta pantalla gráfica se escribe el nombre del archivo para los retiros
actualizados

LOS NUEVOS ARCHIVOS CREADOS PARA EL ARCHIVO

2
 CUENTAS

Archivo de saldos actualizados

Archivos de depósitos actualizados

2
Archivo de retiros actualizados

CONCLUSIÓN

2
Herencia es otro de los conceptos que tiene la programación orientada a objeto
(POO), en este trabajo también se utilizó otros conceptos de la POO para que el
programa se realizara de una mejor manera.
El manejo de herencia es una operación un poco complicada hay que tener mucho
cuidado al momento del llamado en la clase principal.
Espero que este trabajo le haya ayudado de mucho para entender un poco de
herencia.