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

LABORATORIO # 5

HERENCIA

PROFESOR
DIEGO SANTIMATEO

INTEGRANTES
JAIRO CONCEPCIÓN 9-724-1589

FECHA

26 DE OCTUBRE DE 2008

1
 INDICE

Contenidos Pág.

Introducción..................................................................................................... 3
Objetivos......................................................................................................... 4
Descripción del Problema............................................................................... 5
Diagrama UML de Clases.............................................................................. 6
Descripción de las Clases, Métodos y Variables............................................ 7
Class Principal........................................................... ........................... 7
Código Fuente................................................................................ 7
Class FlujoReadln................................................................................. 8,9
Código Fuente................................................................................ 10
Class TodoFlujo................................................................................... 11
Código Fuente................................................................................ 12
Ejecución de la Aplicación, ........................................................................... 13,16
Experiencia.................................................................................................... 16

2
 INTRODUCCIÓN

Este trabajo consiste en crear un programa que utilice los conceptos de herencia, sobrecarga y
polimorfismo, donde vemos que la herencia es la que permitirá la creación de nuevas clases
basadas en clases existentes.
Cuando heredamos de una clase existente, heredamos métodos y campos, y agregamos nuevos
métodos para cumplir con la situación nueva.

En cuanto a la sobrecarga de métodos es la creación de varios métodos con el mismo nombre

pero con diferentes firmas y definiciones.

Aunque también existe la sobrecarga de constructores: Cuando en una clase existen constructores
múltiples, se dice que hay sobrecarga de constructores. Este tipo de sobrecarga se vera en este
trabajo.

Y el polimorfismo es el que implica que un mismo Objeto puede tomar diversas formas.

En este trabajo se podrán observar estos puntos de una manera simple y sencilla.

3
 OBJETIVO DEL PROGRAMA

• Calcular el saldo actual de cada cuenta y escribirlo en un archivo

• Calcular el total de retiro de cada cuenta y escribirlo en un archivo
• Calcular el total de depósito de cada cuenta y escribirlo en un
archivo.
• Manejar e implementar la herencia.
• Manejar e implementar la sobrecarga.
• Manejar e implementar el polimorfismo.

4
 DESCRIPCIÓN DEL PROBLEMA

El programa debe 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.

5
 Class Principal
String nom;

Objetos -Clases
FlujoReadln ManejoFlujo = new FlujoReadln(nom);

ManejoFlujo.Leer();

Main()

Class Estudiante
Class FlujoReadln
BufferedReader in;
BufferedReader in; InputStreamReader isr;
PrintWriter Deposito; PrintWriter Retiro;
PrintWriter Retiro; PrintWriter ar;
PrintWriter Saldo;

BufferedReader Leer()
FlujoReadln(nom) PrintWriter Deposito()
BufferedReader Leer() PrintWriter Retiro()
PrintWriter Deposito()
PrintWriter Saldo()

6
CODIGO FUENTE
import java.io.*;
import javax.swing.*;
import java.lang.*;

class Flujo {

public static void main(String[] args) throws IOException {

String nom = JOptionPane.showInputDialog(null,"Introduzca el nombre del archivo");

FlujoReadln ManejoFlujo = new FlujoReadln(nom);

Como el método Lee() devuelve un
objeto del archivo que contiene las
transacciones, aquí efectuó en cierre
ManejoFlujo.Leer().close(); del archivo; el método Lee() tiene
que ser del mismo tipo del de la
clase TodoFlujo al de la clase
} FlujoReadln para que exista el
} polimorfismo.

Clase principal Flujo

Esta clase se encarga de manejar el proceso que se realizara la creación de los archivos de saldo,

retiro y retiro. La clase Flujo invoca a la clase FlujoReadln para luego utilizar el método Leer()

que se encargara de realizar los cálculos de las transacciones.

7
CODIGO FUENTE DE LA CLASE FlujoReadln
El objetivo de esta clase es el de realizar las transacciones de
import java.io.*;
import javax.swing.*; los diferentes tipos de cuentas que se encuentran en un
import java.net.*;
Herencia archivo, el cual tendrá que sumar todos los Depositos, los
import java.lang.*; retiros de cada cuenta y sacar el saldo de cada cuenta para
luego escribir en un archivo de deposito todos los depósitos y
public class FlujoReadln extends TodoFlujo{
en un archivo de retiro todos sus retiros y también en otro
private BufferedReader in; archivo el saldo actual de cada cuenta.
private PrintWriter Deposito,Retiro,Saldo;

public FlujoReadln(String nom)throws IOException{ Polimorfismo

super(nom);
}
public BufferedReader Leer() throws IOException{ Aquí se observa que
String s; la clase FlujoReadln
String NumC=""; contiene un método
int saldofinal=0; llamado Lee() el cual
int sw=0;
int DatosDep=0; también existe en la
int DatosRe=0; clase Todo flujo y del
int saldoactual=0; mismo tipo
int sumasaldo=0;
int sumadeposito=0;
int sumaretiro=0;

this.in = super.Leer(); Llamado de Métodos que

Deposito = super.Deposito(); los métodos se heredan de
Retiro = super.Retiro(); de la clase la clase Todo
Saldo = super.Saldo();
Todo flujo Flujo
while ((s=in.readLine())!=null){

String[] trans = s.split(" ");

saldoactual = Integer.parseInt(trans[2]);

if(sw==0){ Entra solamente la

sw=1; primera vez para
NumC=trans[0]; inicializar el numero de
} cuenta
if(!NumC.equals(trans[0])){

Escribe en el los Saldo.println("Cuenta Nº "+NumC+" Saldo: "+saldofinal);

archivos de Deposito.println("Cuenta Nº "+NumC+" Depositos: "+DatosDep);
deposito, retiro y
saldo Retiro.println("Cuenta Nº "+NumC+" Retiros: "+DatosRe);

NumC=trans[0];
saldofinal=0;
DatosDep=0;
DatosRe=0;

8
 if(trans[1].equals("0"))
{ Saldo actual del
saldofinal+=saldoactual;
}
cliente
else{

if(trans[1].equals("1")){

Deposito que saldofinal+=saldoactual;

realiza el
cliente DatosDep+= saldoactual;

sumadeposito+=saldoactual;
}

else{

if(trans[1].equals("2")){
Retiro que
realiza el saldofinal-=saldoactual;
cliente
DatosRe+= saldoactual;

sumaretiro+=saldoactual;

}
}

NumC=trans[0];
}
Saldo.println("Cuenta Nº "+NumC+" Saldo: "+saldofinal);
System.out.println("dada"+saldofinal);
Saldo.println("-------------------------------------------------------------");
Saldo.println("9999 "+"3"+" "+sumasaldo);
Deposito.println("Cuenta Nº "+NumC+" Depositos: "+DatosDep);
Deposito.println("-------------------------------------------------------------");
Deposito.println("9999 "+"3"+" "+sumadeposito);
Retiro.println("Cuenta Nº "+NumC+" Retiros: "+DatosRe);
Retiro.println("-------------------------------------------------------------");
Retiro.println("9999 "+"3"+" "+sumaretiro);
System.out.println("Se estan realizando las operaciones espere un momento" );
System.out.println("-------------------------------------------------------------");
System.out.println("Las transacciones de Deposito, Retiro y Saldo actual se han" );
System.out.println("registrado en sus respectivos archivos" );
System.out.println("-------------------------------------------------------------");
Saldo.close();
Deposito.close();
Retiro.close();
return(in);
}

9
}
Class FlujoReadln
Variables de la Clase
Nombre Tipo
in BufferedReader
Deposito PrintWriter
Retiro PrintWriter
Saldo PrintWriter

Métodos Descripción - Funcionamiento

Este método calcula el tota de depósitos, retiros y
Leer() BufferedReader saldo total de cada cuenta y el total de cada uno de
estos tres puntos con el numero de cuenta 9999.
Variables locales
Variable tipo objeto para almacenar cada linea del
s String
archivo.
NumC String Contiene el numero de cuenta

saldofinal int Contiene el saldo final de cada cuenta

sw int Permitira inicializar la variable NumC

DatosDep int Almacenara el total de deposito de cada cuenta

DatosRe int Almacenara el total de retiro de cada cuentta

Contiene la cantidad que se encuentre en cada
saldoactual int
cuenta y transacción.
sumasaldo int Contiene la suma total de todas las cuentas
Contiene la suma total de los depositos de todas
sumadeposito int
las cuentas.
Contiene la suma total de los retiros de todas las
sumaretiro int
cuentas.
Contiene los valores que se dividieron por medio de
tras String
un split.

10
CODIGO DE LA CLASE TODOFLUJO

import java.io.*;
import javax.swing.*;
import java.net.*;

public class TodoFlujo{

private BufferedReader in;

private InputStreamReader isr;
Sobrecarga de los constructores

private PrintWriter ar;

Constructor
public TodoFlujo(String Name)throws IOException{ que maneja el
FileReader arch1 = new FileReader(Name); flujo de un
this.in = new BufferedReader(arch1); archivo

public TodoFlujo()throws IOException{/ Constructor

this.isr=new InputStreamReader(System.in); que maneja el
this.in = new BufferedReader(isr); flujo desde el
teclado
}

public TodoFlujo(int w,String Name)throws IOException{

Constructor
que maneja el
flujo de un
documento 11
URL
 URL rutaservi=new URL(Name);
URLConnection pag=rutaservi.openConnection();
InputStream is=pag.getInputStream();
this.isr=new InputStreamReader(is);
this.in = new BufferedReader(isr);
Polimorfismo }

public BufferedReader Leer()throws IOException{ Método que devuelve

return(in); un objeto de tipo
} BufferReader para
luego ser leído
public PrintWriter Deposito()throws IOException{
FileWriter dll = new FileWriter ("Deposito.txt");
BufferedWriter jpg = new BufferedWriter (dll);
return(ar = new PrintWriter (jpg)); Escritur
} a en los
public PrintWriter Retiro()throws IOException{
FileWriter dll = new FileWriter ("Retiro.txt");
archivo
BufferedWriter jpg = new BufferedWriter (dll);
return(ar = new PrintWriter (jpg)); de
} saldo,
public PrintWriter Saldo()throws IOException{
FileWriter dll = new FileWriter ("Saldo.txt");
retiros y
BufferedWriter jpg = new BufferedWriter (dll);
return(ar = new PrintWriter (jpg));
deposito
}

12
 EJECUCIÓN DEL PROGRAMA

Archivo transacciones
es la que contiene todas
las cuentas

Carpeta donde debe

aparecer los archivos
que programa creara

Se introduce el
nombre del archivo
que contiene las
transacciones

13
Cuando el programa termina de realizar el
proceso, despliega este mensaje.

El color de fondo de la consola es por la

impresión de la imagen en negro

Cuentas que
contiene este
archivo, contiene 6
cuentas, las cuales
cuentas con saldo
inicial, depósitos y
retiros

14
 Archivos
creados

Archivo que
muestra el
total de
deposito que
Suma total se realizo en
cada cuenta

Archivo que
muestra el
total de retiro
que se realizo
en cada
Suma total
cuenta

Archivo que
muestra el
total del saldo
de cada
numero de
cuenta Suma total

15
 Aquí se puede observar los 3 archivos creados
con sus respectivos nombres

/****************************************************************************/

Experiencia
Bueno la experiencia que adquirí fue el de conocer y manejar un poco más el
concepto e implementación de herencia, polimorfismo y sobrecarga, ya que
en este laboratorio pienso que lo utilice de una manera sencilla, pero me
gustaría mejorar más. Creo que en cada laboratorio voy mejorando un poco
más en cuanto a la codificación porque trato de reducir un poco más los
códigos de cada método ya que java nos permite crear programas de una
manera modular y por eso pienso que esa es una de las grandes ventajas de
java.

Mis dificultades fueron pocas, como fue en el caso de que al momento de

calcular todas las cuentas y escribirlas en cada archivo me aparecían
valores que no eran los que se esperaban pero al volver a analizar el
problema medí cuenta de que la variable saldoactual la estaba inicializado
de una manera incorrecta, a que no se tenia que inicializar dentro de el if
donde se encontraba.

16