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

PROYECTO #3
Jerarquía y Herencia

ESTUDIANTES

Montes Diomedes 9-723-640

Rodríguez Misael 8-406-874

PROFESOR:
Diego Santimateo

Fecha de entrega
13-11-2007

INTRODUCCIÓN

1
En este proyecto nos centraremos en la Jerarquía y Herencia en POO, con la finalidad
de utilizar estos conceptos en la construcción de un programa, la cual haga más fácil o
confiable la implementación de este, donde ponemos en practica la utilización de
recursos como los diagramas UML, dándonos una facilidad más practica para el logro
de este proyecto.
A medida que vamos desarrollándolo, podemos decir que son como pasos que se dan
para el logro del mismo, teniendo siempre en cuenta que hay que poner en función los
conocimientos adquiridos a lo largo de este curso.
Y en base a este tema vemos que la Jerarquía y Herencia en POO, nos facilita o nos
brinda múltiples facilidades que implementándolas en un programa nos hace una
función mucha más clara y sencilla.
Al culminar este proyecto se amplio mucho más los conceptos e ideas que
manteníamos, todo esto por el motivo de que existen muchas referencias sobre el
tema.

2
 Objetivo

OBJETIVO GENERAL

 Analizar los conceptos involucrados con la Jerarquía en Java.

Tarea a realizar

Este laboratorio consiste en analizar los conceptos involucrados con la Jerarquía

en Java, para ello el o la estudiante debe tomar como punto de partida de su
investigación los siguientes temas: Jerarquía, Interfaz, Herencia, Clase Abstracta,
Super Clase, Polimorfismo y Sobrecarga.
En una primera fase se deben establecer por lo menos diez fuentes de
información y comentarlas, así como presentarlas en un formato reconocido
internacionalmente o estándar (http://www.ub.es/biblio/citae-e.htm ).
Posteriormente se concretará un glosario de términos debidamente definidos,
destacando la interpretación que el o la estudiante concibe de los mismos.
Seguidamente se procederá a ejemplificar cada concepto bajo un dominio
conocido o previamente experimentado. No olvide explicar su ejemplo.
Finalmente se presentará una aplicación (ejecutable) debidamente
documentada, seleccionada por el o la estudiante donde se hace uso de los conceptos
analizados, para la solución de un problema científico o de la realidad nacional o
institucional.

Cada estudiante debe presentar una propuesta de su aplicación apoyada en

especificaciones UML.

3
I – Fase:

Fuentes de información y comentarios:

Fuente:

1. Ángel Franco García. Programación en Lenguaje Java, la herencia y el

polimorfismo. [en línea]. Universidad del País Vasco (España). Fecha de
creación Enero de 2000. Ultima Actualización, diciembre de 2001.
<http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/herencia/intro_heren
cia.htm > [Consulta: 6 Nov. 2007].

Comentario:
Brinda descripciones y conceptos respecto a la Programación Orientada a Objetos,
principalmente de; Herencia, Jerarquía de Clases, interfaces. de igual manera
especifica y brinda ejemplos sobre su utilidad y aplicación.

Fuente:

2. Agustín Froufe. Conceptos Básicos de Java, Herencia [en línea]. Fecha de

creación (no especifica).Ultima Actualización: 1 de Enero de 1997
<http://www.cica.es/formacion/JavaTut/Cap1/heren.html>
[Consulta:6 Nov. 2007].

Comentario:
Aquí nos da el concepto de Herencia, donde nos habla sobre los objetos en base a los
ya existentes, y de la clave extends, que podemos usar para generar una subclase,
también nos muestra ejemplos de cómo se utiliza este concepto en un programa.
Todo lo que contenga la clase es heredada por la subclase, y esta puede tener sus
propios métodos y variables.

Fuente:

3. Agustín Froufe. Conceptos Básicos de Java, Clases Abstractas [en línea]. Fecha
de creación (no especifica).Ultima Actualización: 1 de Enero de 1997
<http://www.cica.es/formacion/JavaTut/Cap1/abstr.html> [Consulta: 6 Nov. 2007].

Comentario:

En esta dirección nos explica como se puede declarar clases para solo saber que
hacen, sin la necesidad de que estas tengan que usar métodos. Por lo que cada
persona que las use puede definirlo con carácter propio pero ser usado por otros más.
Cuando una clase contiene un método abstracto tiene que declararse abstracta. No
obstante, no todos los métodos de una clase abstracta tienen que ser abstractos.

4
Fuente:
4. Agustín Froufe. Conceptos Básicos de Java, Interfases [en línea]. Fecha de
creación (no especifica).Ultima Actualización: 1 de Enero de 1997
http://www.cica.es/formacion/JavaTut/Cap4/interf.html[Consulta:8 Nov. 2007].

Comentario:

Esta nos habla acerca de que la interface es la parte que hace interactuar el programa
con quien lo implementa, y es una parte importante de la aplicación, donde al no usar
uno simple puede que no obtengamos el máximo del provecho deseado por él.
Aquí nos muestra elementos fáciles para construir interfaces más eficientes.

Fuente:

5. Wikipedia Org. Encapsulación [en línea]. Esta página fue modificada por última
vez el 19:49, 27 oct 2007.
<http://es.wikipedia.org/wiki/Encapsulaci%C3%B3n_(programaci%C3%B3n_orie
ntada_a_objetos)> [Consulta:8 Nov. 2007].

Comentario:

Nos dice como denominar “encapsulación”, que sería ocultar el estado, o los datos de
algún objeto, que solo se modifique por las operaciones de él mismo.
Donde cada uno de ellos no se concreta con el exterior, dando como opción que nadie
que tenga derecho a modificarlo lo haga.

Fuente:

6. Autor Sun (Ciudad Real, España). Programación en Castellano, Subclases [en

línea]. Traductor; Juan Antonio Palos (Ozito). Fecha de creación 1999.
<http://www.programacion.com/java/tutorial/java_basico/21/> [Consulta 8 de nov.
2007.]
Comentario:

Aquí nos habla sobre como crear subclases de una superclase, que vendría siendo
como la de la Herencia, siendo este un tutorial el cual no habla de ancestros que son
directos, o sea, que llevan un modelo especifico de secuencia invariable, ya que, si
existiera un error habría que verificar ese árbol genealógico, por decirlo así. Aquí nos
da una Regla que para nosotros es importante:
Una subclase hereda todas las variables miembros de su superclase que puedan ser
accesibles desde la subclase (a menos que la variable miembro esté oculta en la
subclase).

5
Fuente:

7. Arnold y Gosling,.6. Herencia, Guía de Iniciación al Lenguaje JAVA, VERSIÓN

2.0 - Octubre de 1999, Ultima actualización 1997.

http://pisuerga.inf.ubu.es/lsi/Invest/Java/Tuto/Index.htm [consulta 11 Nov. 2007]

Comentario:

Este trabajo corresponde a una guía que sirva de iniciación a la programación en el

lenguaje Java. En él se tratan los diversos aspectos básicos que comprenden el
aprendizaje de un lenguaje de programación, así como una breve noción de la
Programación Orientada al Objeto en la que Java se basa.

Así mismo se incluyen comparativas con otros lenguajes de programación (especial

hincapié en C++), y se tratan con un poco más de profundidad bibliotecas gráficas
como AWT y Swing.

Se comentan también aspectos relacionados con Internet, como son las bibliotecas de
Sockets y las famosas applets de Java.

Fuente:

8. Agustín J. González, Herencia en Java, Diseño y Programación Orientados a

Objetos, [en línea]. Fecha de creación (no especifica).Ultima Actualización: (no
especifica).

http://profesores.elo.utfsm.cl/~agv/elo329/1s04/lectures/JavaInheritance.ppt [consulta:
11 Nov 2207]

Comentario:

Esta página se muestra en formato de power point, donde nos orienta en la creación de
clases tomando como referencia en otras, dándonos la opción de utilizar los mismos
métodos, como el crearles nuevos, también nos da ciertos sinónimos para la
superclase como lo son clase padre o clase base y que las nuevas podrían ser
subclases o clases hijas o derivadas.
Como también nos habla del polimorfismo, con un leve ejemplo; en otro habla
sobre la sobrecarga.

6
Fuente:

9. Andrés Montano Pellegrini., Extendiendo el Comportamiento de las Clases:

Herencia en Java , [en línea]. Fecha de creación 2006, Ultima actualización( no
especificada).
http://www.gaugeus.com/ramblings/2006/11/25/extendiendo-el-comportamiento-de-las-
clases-herencia-en-java-inheritance-in-java > [consulta: 11 Nov 2007].

Comentario:

Esta página nos describe la habilidad de utilizar una clase ya implementada y

agregarle comportamiento y estado a esta. Así, la nueva clase seria una extensión de
la clase original. Ha esto se le llama herencia, que es nuestro tema en este proyecto.
Tambien nos muestra conceptos sobre polimorfismo, clases, métodos los cuales son
utilizables e importantes dentro de cualquier programa.

Fuente:
10. Autor Desconocido, FUNDAMENTOS DE INFORMÁTICA, Introducción a
Java (II),[en línea]. Fecha de creación (no especifica).Ultima Actualización: (no
especifica).

http://members.tripod.com/tutorial_bh.mx/obj_y_clases.html > [consulta 11 Nov 2007]

Comentario:

En esta página nos habla también sobre el tema a investigar, pero lo que más llamó
nuestra atención fue la parte que nos describe la herencia en datos privados, donde
nos manifiesta que si la clase madre posee métodos private las subclases de ella no
pueden acceder a estos métodos porque solo le pertenecen a ella, o sea, que no es
heredable, Pero si se puede acceder desde la subclase a un método de la clase madre
que usa ese dato.

7
 GLOSARIO DE TÉRMINOS

1. INTERFAZ: Los métodos abstractos son útiles cuando se quiere que cada
implementación de la clase parezca y funcione igual, pero necesita que se cree
una nueva clase para utilizar los métodos abstractos.
Los interfaces proporcionan un mecanismo para abstraer los métodos a un nivel
superior.
Un interfase contiene una colección de métodos que se implementan en otro
lugar. Los métodos de una clase son public, static y final.
La principal diferencia entre interface y abstract es que un interface proporciona
un mecanismo de encapsulación de los protocolos de los métodos sin forzar al
usuario a utilizar la herencia

2. JERARQUÍA: La jerarquía consiste en la relación resultante que se da entre

una superclase y una subclase a esto se le llama jerarquía.

3. HERENCIA: es uno de los conceptos más cruciales en la POO. La herencia

básicamente consiste en que una clase puede heredar sus variables y métodos
a varias subclases (la clase que hereda es llamada superclase o clase padre).
Esto significa que una subclase, aparte de los atributos y métodos propios, tiene
incorporados los atributos y métodos heredados de la superclase. De esta
manera se crea una jerarquía de herencia.

4. CLASE ABSTRACTA: es una clase de la que no se puede crear objetos. La

utilidad de estas clases esta en que otras clases hereden de ésta, por lo que con
ello se consigue que se reutilice el código. Para declarar una clase como
abstracta utilizamos la palabra clave abstract.
Un clase abstracta es una descripción incompleta de algo. Un conjunto de
operaciones y atributos que por sí solos no describen nada.
5. SÚPER CLASE: Clase que esta siendo extendida. Es el nombre que reciba la
clase padre de donde los métodos y variables.

6. POLIMORFISMO: Se da cuando varios objetos de distintas clases pueden

recibir el mismo mensaje y ser capaces de responderlo.

7. SOBRECARGA: consiste en poder tener varios métodos o constructores con el

mismo nombre dentro de una misma clase y que no hagan las mismas cosas.

8. ENCAPSULACIÓN: es el término de orientación a objetos que describe la

vinculación de unas operaciones y estado a un objeto particular. La
encapsulación está íntimamente relacionada con ocultar la información,
definiendo qué partes de un objeto son visibles y qué partes están ocultas.

9. THIS: palabra clave que hace referencia a los miembros de la propia clase.

8
10.SUPER: palabra clave que se usa si se necesita llamar al método padre dentro
de una clase que ha reemplazado ese método. Super permite acceder, desde la
subclase, a los métodos y las variables de la superclase.

11.SUBCLASES: Las subclases se distinguen por las siguientes características:

 Heredan aquellas variables miembros declaradas como public o protected
 Heredan aquellas variables miembros declaradas sin especificador de
acceso (normalmente conocidas como "Amigas") siempre que la subclase
esté en el mismo paquete que la clase
 No hereda las variables miembros de la superclase si la subclase declara
una variable miembro que utiliza el mismo nombre. La variable miembro
de la subclase se dice que oculta a la variable miembro de la superclase.
 No hereda las variables miembro private.
 Ocultar Variables Miembro.
Como se mencionó en la sección anterior, las variables miembros definidas
en la subclase ocultan las variables miembro que tienen el mismo nombre en
la superclase.
Como esta característica del lenguaje Java es poderosa y conveniente,
puede ser una fuente de errores: ocultar una variable miembro puede
hacerse deliberadamente o por accidente. Entonces, cuando nombres tus
variables miembro se cuidadoso y oculta sólo las variables miembro que
realmente deseas ocultar.
Una característica interesante de las variables miembro en Java es que una
clase puede acceder a una variable miembro oculta a través de su
superclase. Considere este pareja de superclase y subclase.

9
Ejemplificación de conceptos bajo un dominio conocido o previamente
experimentado:

CLASE ABSTRACTA
El dominio es un Restaurante.
La clase Cocinero es la superclase Abstracta y contiene el método imprimir el cual es
abstracto. La clase mesero hereda de la clase y se hace uso de el método imprimir
mediante el llamado del objeto de la clase Mesero.

import javax.swing.*;
import java.text.*;
class Restaurante //Clase Principal
{
public static void main(String args[]){ //Creación del objeto mesero
Mesero objeto = new Mesero();
objeto.imprimir();
}
}
abstract class Cocinero { //clase Abstracta
public abstract void imprimir();
}//fin de la clase
class Mesero extends Cocinero {// la clase mesero es una extensión de la clase
cocinero
public void imprimir(){ //metodo que despliega el menú
System.out.println("Digame Joven que Desea");
System.out.println("Tenemos Comida Corriente");
System.out.println("Sancocho");
System.out.println("Arroz con camarones");
}
}

// Ejemplo de Polimorfismo.
import java.io.*;
import javax.swing.*;
import java.lang.String.*;

class Forma {
void dibujar() {}
void borrar() {}
}

class Circulo extends Forma {

10
 void dibujar() {
System.out.println("Circulo.dibujar()");
}
void borrar() {
System.out.println("Circulo.borrar()");
}
}

class Cuadrado extends Forma {

void dibujar() {
System.out.println("Cuadrado.dibujar()");
}
void borrar() {
System.out.println("Cuadrado.borrar()");
}
}

class Triangulo extends Forma {

void dibujar() {
System.out.println("Triangulo.dibujar()");
}
void borrar() {
System.out.println("Triangulo.borrar()");
}
}

public class Formas

{
public static Forma formaAleatoria() {
switch((int)(Math.random() * 3)) {
default:
case 0: return new Circulo();
case 1: return new Cuadrado();
case 2: return new Triangulo();
}
}
public static void main(String[] args) {
Forma[] s = new Forma[9];
// Rellenar el array con varias formas:
for(int i = 0; i < s.length; i++)
s[i] = formaAleatoria();
// llamar a los método para ver el polimorfismo:
for(int i = 0; i < s.length; i++)
s[i].dibujar();
}
}

11
Comentario:
El concepto en este ejemplo nos describe lo que podemos decir es que utiliza el mismo
método void dibujar en distintas clases, y nos muestra las diferentes salidas que da
este programa en las clases Forma y Formas.

DESCRIPCIÓN DEL DOMINIO

El desarrollo de nuestra aplicación simula un Sistema Bancario que realiza las transacciones
básicas que un cliente de un banco efectuá, el sistema permite a través de un menú realizar al
usuario ;
1. Abrir una cuenta don de el cliente deberá realizar un depósito inmediato, se le asignara
un numero de cuenta generado aleatoriamente, con el cual podrá realizar transacciones
posteriormente. El numero de cuenta será a la vez el nombre del archivo donde se
almacenara la información del cliente (numero de cuenta, nombre, cédula, dirección).
2. Realizar un deposito a una cuenta ya existente, se le solicitará que ingrese el numero de
cuenta para realizar esta transacción, se verificará la existencia de la cuenta dependiendo
existe el archivo con el nombre de la cuenta (si la cuenta existe). Se registrara el
deposito y se actualizará el saldo en el mismo archivo o cuenta.
3. Realizar un retiro a una cuenta ya existente, se le solicitará que ingrese el numero de
cuenta para realizar esta transacción, se verificará la existencia de la cuenta dependiendo
existe el archivo con el nombre de la cuenta (si la cuenta existe). Se registrara el retiro y
se actualizará el saldo en el mismo archivo o cuenta.
4. ver estado de la cuenta, se le solicita el numero de cuenta para verificar la existencia de la
cuenta dependiendo existe el archivo con el nombre de la cuenta (si la cuenta existe). A
continuación se muestra los detalles de la cuenta.

12
 Diagrama UML de clases, atributos y métodos.

GestionBancaria

Main();

abstract class Abstr abstract class Abstr2

abstract void realizar();

abstract void cuenta();

abstract void realizar(String abrir);
abstract void consulta();

class Deposito class NumeroCuenta

numcue
nomb
ced,
void consulta()
dir
void realizar()
dep
void cuenta();
13
Jerarquía y Herencia

DESCRIPCIÓN DE LAS
CLASES

Clase Atributos Comportamiento

Principal2 Main(): contiene el

menú con la opciones a que
el cliente desea realizar
abstract void realizar();
abstract class Abstr método abstracto que de la
clase Depósito
abstract void
realizar(String abrir);
método abstracto clase
Depósito
abstract void
consulta(); Este método
abstracto de la clase
Depósito

abstract class Abstr2 abstract void cuenta();

Método abstracto del clase
NumeroCuenta

void cuenta();este
String numcue, método mediante random
nos da al azar un numero de
String nomb, cuenta para ser guardado
class NumeroCuenta String ced, posteriormente en un archivo
con dicho número como
String dir, nombre y captura los datos
del archivo.
String dep;

Diomedes Montes J, Misael Rodríguez

Jerarquía y Herencia

void realizar():
este método abre el archivo
de la cuenta y realiza la
transacción de deposito.
void realizar(String
abrir):
este método abre el archivo
de la cuenta y realiza la
class Deposito transacción de retiro.

Hay sobrecarga de métodos

que se applica dependiendo
de la opcion ingrasada en el
menu principal
(depostito_retiro)
void consulta() Este
método nos abre el archivo
de la cuenta y lo muestra
con su respectivo saldo
actual.

CODIGO FUENTE DE LA APLICACIÓN

/* Clase abstracta que contiene las interfases o métodos abstractos */

import java.io.*;

abstract class Abstr

{
abstract void realizar(); // interfaz o métodos abstractos
abstract void realizar(String abrir);
abstract void consulta();
}
***************************************************************************************************
*********

/* Clase abstracta que contiene las interfases o métodos abstractos */

import java.io.*;

abstract class Abstr2

{
abstract void cuenta(); // interfaz o método abstracto
}

***************************************************************************************************
*********

/*Clase principal que contiene el menú con las opciones que el usuario podra
realizar;

Diomedes Montes J, Misael Rodríguez

Jerarquía y Herencia

. Abrir una Cuenta, Realizar Depósito, Realizar Retiro, Ver estado de cuenta, Salir
del Sistema, dentro de las opciones se invocan a los metodos que cumplen cada
funcion antes mencionadas */

import javax.swing.*;
import java.text.*;
import java.lang.*;

class GestionBancaria
{
public static void main(String[] args)
{
String opcion;
int opc=0;
int cta=0;

do{

opcion=JOptionPane.showInputDialog(null," SISTEMA DE GESTIÓN

BANCARIA\n"+" MENU\n"+"**********Seleccione una
Opcion**********\n"+"1. Abrir una Nueva Cuenta\n"+"2. Realizar Depósito a una
Cuenta\n"+"3. Realizar Retiro de una Cuenta\n"+"4. Ver estado de una Cuenta\n"+"5.
Salir del Sistema\n");

opc=Integer.parseInt(opcion);

switch (opc)
{
case 1: {
NumeroCuenta objeto=new NumeroCuenta(); //inicializa
constructor
objeto.cuenta(); //invoca al metodo que crea una cuenta
}
break;
case 2: {
Deposito objeto1=new Deposito(); //inicializa constructor
objeto1.realizar(); //invoca al método que realiza un
déposito a una
cuenta
}
break;
case 3: {
String abr = JOptionPane.showInputDialog(null, "INDIQUE EL
NUMERO
DE CUENTA:");
Deposito objeto2=new Deposito();//inicializa constructor
objeto2.realizar(abr); //invoca al método que realiza un
retiro de
una cuenta, Ademas hay
sobrecraga
de métodos
}
break;
case 4: {
Deposito objeto3=new Deposito();

Diomedes Montes J, Misael Rodríguez

Jerarquía y Herencia

objeto3.consulta(); //invoca al método que muestra el

estado
actual de la cuenta
}
break;
case 5: {

JOptionPane.showMessageDialog(null,"*****fin del
programa*****");
}
break;
}

}while(opc!=5);
}
}
***************************************************************************************************
*********

/* la SubClase NumeroCuenta extendida de la clase abstracta (Abstr2) creará una

nueva cuenta, la cual asignará al cliente un número de cuenta,así mismo la clase
crea un archivo para guardar los datos del cliente; este nombre del archivo es
igual al número de la cuenta. para crear una cuenta el cliente deberá realizar un
déposito inmediato*/

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

class NumeroCuenta extends Abstr2{ //subclase NumeroCuenta

private String numcue, nomb,ced,dir,dep;

public NumeroCuenta() //constructor

{
}

void cuenta(){

int numeroCuenta = (int) (Math.random()*100000+100);// funcion que genera un

numero
aletario para el
numero de
cuenta
String s = String.valueOf(numeroCuenta); // metodo que convierte el numero
a String
para nombre de archivo.

try {
FileWriter arch2 = new FileWriter(s+".txt"); //nombre del archivo, que a vez es
igual al
número de cuenta

BufferedWriter in2 = new BufferedWriter(arch2);

PrintWriter salida = new PrintWriter(in2);

Diomedes Montes J, Misael Rodríguez

Jerarquía y Herencia

//se guardan los datos del cliente el el archivo

salida.println("1. NUMERO DE CUENTA: "+s);
nomb = JOptionPane.showInputDialog(null, "Escriba el nombre
del
cliente:");
salida.println("2. NOMBRE: "+nomb);
ced = JOptionPane.showInputDialog(null, "Escriba la cédula:");
salida.println("3. CEDULA: "+ced);
dir = JOptionPane.showInputDialog(null, "Direccion del cliente:");
salida.println("4. DIRECCION: "+dir);
dep = JOptionPane.showInputDialog(null, "Ahora realice su
deposito:");
salida.println("5. DEPOSITO: "+dep);
salida.println("6. SALDO: "+dep);

in2.close();
}
catch (Exception e)
{
System.err.println("***Error al crear el archivo...\n" +e);
}

JOptionPane.showMessageDialog(null,"SE HA ABIERTO LA CUENTA\n\n "+"El

Numero de
Cuenta es: "+ s);

return;

}
}

***************************************************************************************************
*********
/*SubClase extendida de la clase abstracta (Abstr) que permite realizar; un
deposito a una cuenta, un retiro a una cuenta, ver estado de una cuenta. para
realizar estos trámites se le solicitará al cliente el numero de cuenta, a partir de
este numero se busca el archivo que contiene los datos de la cuenta; ya que
ambos son los mismos, se aprecia una sobrecarga de métodos en "realizar" */

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

class Deposito extends Abstr // subclase Deposito

{
public Deposito() //constructor de la clase
{
}

Diomedes Montes J, Misael Rodríguez

Jerarquía y Herencia

void realizar(){ //método que realizará un deposito a una cuenta, y actualizara su

saldo

String abrir = JOptionPane.showInputDialog(null, "INDIQUE EL NUMERO DE

CUENTA:");

try {
FileReader arch1 = new FileReader(abrir); //se lee el archivo o cuenta
BufferedReader in = new BufferedReader(arch1);

String linea;
String dts=" ";
while(((linea=in.readLine())!= null)&&(!linea.startsWith("6. SALDO:")))
//busca el
saldo de
la cuenta
{
dts +=linea + "\n";
}

String[] var = linea.split(": ");

System.out.println(var[1]);
int aa=Integer.parseInt(var[1]);

//nuevo
déposito
String dep = JOptionPane.showInputDialog(null, "Ahora realice su
deposito:");

int dep2=Integer.parseInt(dep);
aa = aa + dep2; //incrementa el saldo de la cuenta

FileWriter fw = new FileWriter (abrir); // se escriben todos datos en

archivo actual
BufferedWriter bw = new BufferedWriter (fw);
PrintWriter pasaArch = new PrintWriter (bw);

String result = dts + "\n" + "5.NUEVO DEPOSITO: " + dep + "\n" + "6.NUEVO
SALDO: "+aa;

pasaArch.println(result); //se escriben los datos de la transaccion en el archivo

(nuevo
deposito, saldo actual)

try {
bw.close(); //cierre del archivo original
}
catch ( IOException e )
{
System.err.println( "El archivo no se pudo cerrar
correctamente" );
}

Diomedes Montes J, Misael Rodríguez

Jerarquía y Herencia

catch (Exception e)
{
System.err.println("**NO SE PUEDE ENCONTRAR LA CUENTA
ESPECIFICADA**\n" + e);
}
}

/....................................................................................................................../
void realizar(String abrir){ //metodo que realiza un retiro a una cuenta y actualiza el
saldo
//hay sobrecarga de métodos este
recibe parametros, el anterio no

try {

FileReader arch1 = new FileReader(abrir); //lee el archivo, cuenta

BufferedReader in = new BufferedReader(arch1);

String linea;
String dts=" ";
while(((linea=in.readLine())!= null)&&(!linea.startsWith("6. SALDO:")))
{

dts +=linea + "\n";

}

String[] var = linea.split(": ");

System.out.println(var[1]);
int aa=Integer.parseInt(var[1]);

String dep = JOptionPane.showInputDialog(null, "Ahora realice su

Retiro:");//nuevo
retiro

int dep2=Integer.parseInt(dep);
aa = aa - dep2; //decrementa el saldo de la cuenta
FileWriter fw = new FileWriter (abrir);
BufferedWriter bw = new BufferedWriter (fw);
PrintWriter pasaArch = new PrintWriter (bw);

String result = dts + "\n" + "5.NUEVO DEPOSITO: " + dep + "\n" + "6.NUEVO
SALDO: "+aa;
pasaArch.println(result);

try {
bw.close(); //cierre del archivo original
}
catch ( IOException e )
{
System.err.println( "El archivo no se pudo cerrar correctamente" );
}

Diomedes Montes J, Misael Rodríguez

Jerarquía y Herencia

catch (Exception e)
{
System.err.println("**NO SE PUEDE ENCONTRAR LA CUENTA
ESPECIFICADA**\n" +e);
}
}
/....................................................................................................................../

void consulta(){ //método que mostrara al cliente el estado actual de la cuenta

String abrir = JOptionPane.showInputDialog(null, "INDIQUE EL NUMERO DE

CUENTA:");

try {

FileReader arch1 = new FileReader(abrir); //lee el archivo

BufferedReader in = new BufferedReader(arch1);

String linea;
String dts=" ";
while(((linea=in.readLine())!= null))
{

System.out.println(linea); //muestra los datos de la

cuenta
}

try {
in.close(); //cierre del archivo original
}
catch ( IOException e )
{
System.err.println( "El archivo no se pudo cerrar
correctamente" );
}

}
catch (Exception e)
{
System.err.println("**NO SE PUEDE ENCONTRAR LA CUENTA
ESPECIFICADA**\n" +e);
}
}

Diomedes Montes J, Misael Rodríguez

Jerarquía y Herencia

Reflexión grupal final:

Nuestro grupo esta conformado por :

 Rodríguez Misael
 Montes Diomedes
Este grupo ha trabajado rigurosamente en este proyecto, donde hemos
consultado todas las fuentes de información suministradas por el profesor y
otras que por motivo de investigación se han visitado en la primera fase de
este.
Al elegir este programa basado en las transacciones de una cuenta, donde se
crea un número al azar y posteriormente este número queda como el nombre
del archivo creado, y por la opción de menú el usuario elije la transacción a
realizar, tanto como también la consulta de dicha cuenta u otra creada
anteriormente. Y por ser un programa agradable en su estructura para nosotros
podemos agregar que ha sido de mucha experiencia en lo que a POO se
refiere.

Conocimientos adquiridos individuales:

Misael Rodríguez:
Por la estructura que conlleva este proyecto implantada por el profesor, que
hace que se investiguen muchos temas o conceptos en Jerarquía y Herencia
en POO, para mí ha sido buena metodología, claro que debe ser efectuada con
responsabilidad, ya que, vendría siendo de auto-aprendizaje, por lo que puedo
decir que he recibido nuevos conceptos o ideas de cómo trabajan estos en java
y poco a poco, con la realización de este curso ir poniéndolos en practica, que
personalmente es lo más eficiente para captarlos.

Diomedes Montes:
A medida que vamos avanzando en POO, como en este proyecto se basa en
Jerarquía y Herencia, voy analizando y uniendo todos los otros conocimientos
de los proyectos y laboratorios anteriores, y voy comprendiendo como java nos
sirve como herramienta al crear programas que hacen que ciertos problemas

Diomedes Montes J, Misael Rodríguez

Jerarquía y Herencia

sean más sencillos de resolver, y de esta manera adquirir nuevos

conocimientos.
CAPTURA DE PANTALLA DE LA APLICACIÓN

Esta es la pantalla que se muestra al ejecutar el programa, mostrándonos el menú

inicial, donde hemos elegido la opción 1 para abrir una cuenta.

Aquí nos solicita el nombre del cliente.

Aquí nos solicita la cedula del cliente.

Diomedes Montes J, Misael Rodríguez

Jerarquía y Herencia

Aquí nos solicita la dirección del cliente.

Esta pantalla solicita la cantidad inicial de la cuenta a crear por el cliente.

Esta pantalla no muestra el mensaje de que se ha creado o abierto una cuenta y nos
muestra también el número de esta, que se creo en forma aleatoria.

Diomedes Montes J, Misael Rodríguez

Jerarquía y Herencia

Aquí le mostramos que al crearse la cuenta que en este caso es la # 40420, la misma
aparece en la carpeta donde se trabaja y tiene por nombre el mismo número, donde
aparecen todos los datos solicitados anteriormente.

Posterior a esto nuevamente nos sale el menú y elegimos la opción 2, y para realizar
un deposito.

Diomedes Montes J, Misael Rodríguez

Jerarquía y Herencia

Esta pantalla se muestra después de elegida la opción 2, y nos pide el número de la

cuenta con la que queremos trabajar, pero tenemos que agregarle “ .txt”, por el motivo
de que dicha cuenta es guardada como un archivo.

Esta pantalla nos solicita la cantidad a depositar en dicha cuenta.

Se muestra otra vez el menú y elegimos la opción 3, para hacer un retiro a la cuenta
ya creada.

Diomedes Montes J, Misael Rodríguez

Jerarquía y Herencia

Nos solicita el número de la cuenta nuevamente para realizar el retiro.

Nos solicita la cantidad que se va ha retirar de la cuenta.

En la opción 4, hacemos una consulta de la cuenta que elegimos.

Diomedes Montes J, Misael Rodríguez

Jerarquía y Herencia

En esta pantalla nos salen los datos del cliente, dueño de la cuenta.

Al elegir la opción 5, damos finalización al programa.

Diomedes Montes J, Misael Rodríguez

Jerarquía y Herencia

Esta pantalla se muestra cuando se introdujo un número de cuenta inexistente, siendo

esto una de las exepciones.

Diomedes Montes J, Misael Rodríguez

Jerarquía y Herencia

BIBLIOGRAFÍAS / WEBGRAFIAS

o Documento pdf. Miguel Angel Abian. Análisis OO.

http://www.javahispano.org/tutorials.item.action?id=25

o Herramienta para diseño de mapa conceptual

http://cmap.ihmc.us/

o Tutorial UML

http://www.dcc.uchile.cl/~psalinas/uml/introduccion.html

o Formato reconocido internacionalmente o estándar

http://www.ub.es/biblio/citae-e.htm

o http://www.javahispano.org/cursotext.viewer.action?file=basico

o http://es.wikipedia.org/wiki/Herencia_(programaci%C3%B3n_orientada

_a_objetos)

o http://www.dcc.uchile.cl/~lmateu/Java/Apuntes/index.htm

o http://www.arrakis.es/~abelp/ApuntesJava/Herencia.htm

o http://www.it.uc3m.es/tsirda/practicas/P13/enunciado.html

o http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/introduccion/indice.html

o http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/herencia/he

rencia1.htm

o http://pisuerga.inf.ubu.es/lsi/Invest/Java/Tuto/II_6.htm

Diomedes Montes J, Misael Rodríguez