UNIBERSIDAD DE PANAMA

CENTRO: CRUV
FACULTAD: INFORMÁTICA
CARRERA: LICENCIATURA EN INGENIERIA EN INFORMÁTICA
CURSO: PROGRAMACIÓN 2
CÓDIGO: 10110
PROFESOR: DIEGO SANTIMATEO
ESTUDIANTE:
LEONARDO BATISTA
SEGUNDO SEMESTRE DEL 2019
 índice
índice ................................................................................................................................................... 2
Introducción ........................................................................................................................................ 3
Enunciado del problema .................................................................................................................... 4
Glosario del dominio donde se desarrolla el problema................................................................... 4
Explicación del programa en java ..................................................................................................... 5
Explicando la clase Banco................................................................................................................. 5
Documentación de la clase SistemaBanco y evidencia del código fuente de la clase SistemaBanco.
.......................................................................................................................................................... 8
Evidencia de la clase Banco............................................................................................................ 13
Evidencia de la clase InteractiveIO. ................................................................................................ 16
Métodos creados por el programador............................................................................................. 18
métodos de la clase Banco ............................................................................................................. 18
Métodos de la clase SistemaBanco. ............................................................................................... 19
Clases y métodos definidos por el lenguaje java .......................................................................... 20
Constructores usados ...................................................................................................................... 21
Datos de prueba ................................................................................................................................ 23
Evidencia de ejecución del programa ............................................................................................. 24
 Introducción
En este trabajo encontraremos la documentación de un programa implementado en java usando la
metodología programación orientada a objeto. El programa se trata de un sistema de banco que
permita que un cliente nuevo habrá una cuenta además el programa o sistema le permitirá al usuario
realizar tantas transacciones como pueda, permitiendo el cierre de la cuenta.
Bueno para mi todos los trabajos o tareas de este tipo son importante, este trabajo fue un reto o por
decirlo mejor, fue la creación del programa en un lenguaje nuevo como java y usando la metodología
básica de la POO fue interesante realizar este trabajo porque me obligo a investigar sobre los tipos
de cuentas que hay y como funciona de forma general cada una, porque si veremos el programa o
problema que había que resolver mediante la programación refería a las cuentas bancarias(ahorros)
y transacciones que realizara el usuario en la aplicación creada.
Otro punto importante al realizar fue porque aprendí a crear la clase InteractiveIO y crear mis propios
métodos de entrada y salida de datos mediante teclado. Además, lo más importante fue la aclaración
de algunos conceptos, que en realidad sabia pero no de forma correcta, porque al tratar de resolver
algún problema me generaba conflictos y dudas que no me permitían avanzar.
 Enunciado del problema

Glosario del dominio donde se desarrolla el problema

Plazo fijo
cuenta ahorro corriente
cuenta ahorro navidad
Banco
Cliente
Saldo inicial
Saldo final
Tipo de cuenta
Fecha de inicio
Fecha de cierre
Tasa de interés
 Explicación del programa en java

Explicando la clase Banco.

En la clase Banco
tendremos los atributos
de la clase Banco e igual
que sus métodos y
constructor.
Como podemos observar
en la figura 1, podemos
notar el comienzo de la
clase Banco, con la
primera línea de código
(línea 1). observamos que
importamos el paquete
java.time.LocalDate, esto
lo hago para declarar 2 de
los atributos de la clase
Banco, como tipo de la
clase LocalDate estos
atributos son la fecha de
apertura de una cuenta
bancaria, y la fecha de
ultimo deposito, como se
muestra en la línea 9 y 14
del código de la figura 1.
Podemos ver otros
atributos de la clase
Banco como el nombre
del cliente o sea el que va
a abrir una cuenta que es
figura 1
de tipo String que igual
una clase, otro atributo
como la tasa de interés este atributo es de tipo double vea figura 1 en la línea 10, otro atributo como
el tipo de cuenta, este será de tipo entero ya que las cuentas son enumeradas como (cuenta ahorro
= 1, cuenta plazo fijo = 2…etc), como vemos cada cuenta tiene un numero identificador o diferente,
otros atributos como el saldo Inicial y el saldo final ambos son de tipo double.
En la figura 1 en la línea 18 a 25 podemos observar el constructor, el constructor lo que realiza es
inicializar el objeto de la clase Banco, que en este caso el objeto sería una persona (cliente). cuando
me refiero a inicializar el objeto es construir el objeto en sí; que pertenece a una clase de objetos.
Démonos cuenta de que inicializar un objeto se le dice constructor, porque se refiere a construir el
objeto.
Como vemos en el constructor inicializamos la fecha del ultimo deposito como la fecha de apertura
(la fecha de ultimo deposito es igual a la fecha de apertura) esto es porque al crear el objeto
automáticamente estamos creando la cuenta, y como al crear una cuenta siempre se deposita un
saldo inicial que tendrá la cuenta al igual que el saldo inicial va a hacer igual que el saldo final.
Los argumentos que recibe el constructor son de tipos de String para dueño de la cuenta, otro tipo de
dato como LocalDate para la fecha de apertura de la cuenta, otra como el saldo inicial que es double
y el también recibe el tipo de cuenta que además es de tipo entero. Vea la figura 1 en las líneas 18 a
25 que es la declaración del constructor.
además de los atributos y
constructores tenemos los
métodos.
Aun siguiendo con la explicación
de la clase Banco. Observamos
el método retiro en este método
lo que hace es que verifica que
tipo de cuenta tiene el cliente,
como se ve en la línea 29 del
código (figura 2) , verificamos si
el cliente puede realizar el retiro y
además compara el saldo actual
del cliente con el saldo que
intenta retirar el cliente, porque
no puede retirar mas de lo que
posee en la cuenta si todo esto
resulta verdad, el cliente puede
hacer retiro, de lo contrario
verifica en la línea 33 (figura 2) el
tipo de cuenta y como es navidad
el cliente no puede realizar retiro,
pero, si en la línea 33 no resulta
verdad, pasa a la línea 38 (figura
2) y compara si el tipo de cuenta
es 3 y si resulta verdad el cliente
no puede hacer retiro, por ser
plazo fijo.
En la línea 48 del código (figura
2) observamos el método figura 2
deposito, en este método se
compara el tipo de cuenta y si el tipo de cuenta es 1 o 2 el cliente satisfactoriamente podrá depositar
el dinero mientras que el cliente que posee una cuenta 3 o plazo fijo no podrá hacer deposito ya que
es una cuenta plazo fijo y el dinero no se podrá tocar en ningún momento, hasta que finalice el plazo.
Tabla 1.
Numero de cuenta Tipo de cuenta
1 Cuenta corriente (ahorro)
2 Cuenta ahorro navidad
3 Cuenta plazo fijo
 Aun siguiendo con la clase
Banco observemos en la
(figura 3) en la línea de código
65 podemos ver el método
cerrar cuenta, básicamente lo
que hacemos en este método
es verificar el saldo final del
cliente y si este es mayor a 0
procederá a cerrar la cuenta,
sacando todo el dinero de ella,
pero si el saldo final resulta ser
cero no se cierra la cuenta por
que como se va ha cerrar una
cuenta que no tiene fondo.
Luego en la line 76 (figura 3)
observamos el método aplicar
interés básicamente este
método se llama cuando el
cliente que tiene tipo de cuenta
1 (cuenta corriente) deposita y
a pasado un mes del ultimo
deposito.
Nota: el método solo se
aplicará una vez al correr el
programa en esta computadora
ya que toma la fecha del
sistema como ultimo deposito,
además este se guarda en la
memoria RAM por lo que una
vez que se corra el programa
se borraran todos los datos del
figura 3 cliente y no quedara
almacenado en ningún archivo
por el estilo.
En la línea 81 observamos el método toString que solo devuelve los datos del cliente o muestra los
datos al usuario cliente, cuando clique o elija la opción ver datos del cliente, aquí los datos los mande
con los métodos get por que en el programa principal en otras operaciones los uso y como para no
dejarlo sin hacer nada los utilizo en este caso.
aún seguimos con la
clase banco.
El método
setUltimoDeposito es
usado para actualizar
la fecha del cliente
cuando realiza el
ultimo deposito.
El método getSaldoFinal es usado para mostrarle por pantalla el saldo Final o sea el saldo actual al
cliente por pantalla.
Y el metodo setTazaInteres es usado para asignarle la taza de interés al cliente si y solo si el cliente
es cuenta corriente o sea 1

Documentación de la clase SistemaBanco y evidencia del código fuente de la clase

SistemaBanco.

En las siguientes imágenes observaremos la estructura principal del programa o clase principal.
La documentación o explicación de cada segmento de código esta remarcada de color amarillo
import java.time.format.DateTimeParseException; //importamos el paquete
time.format.DateTimeParseException muestra mensaje de error al capturar la fecha
import java.time.format.DateTimeFormatter; //DateTimeFormatter lo usamos para dar formato
a la fecha
import java.time.LocalDate; //usado para obtener la fecha del sistema
import java.time.Period; //usado para sacar el periodo de la fecha

public class SistemaBanco {

public static void main(String[] args) {

DateTimeFormatter fechaAp = DateTimeFormatter.ofPattern("dd-MM-yyyy"); //asignando

un formato a la fecha

Banco []cliente = null;

cliente=new Banco[3];

InteractiveIO inputAndOuput = new InteractiveIO();// objeto de entrada y salida

int totalClient=0,pos=0;
LocalDate fecha = null;

System.out.print("\t\t\tBIENVENIDO AL BANCO\n");
System.out.print("\t\t**************************************************");

System.out.println("\nIngresando los Datos de la Cuenta");

for (int i = 0; i < cliente.length; i++) {
inputAndOuput.desplegar("\n\nNombre del nuevo cliente: ");
String nombreCliente = inputAndOuput.capString();
try{
inputAndOuput.desplegar("Fecha de apertura de la cuenta(dd-MM-yyyy): ");
 String fechaString = inputAndOuput.capString(); //capturando la fecha
como string
fecha = LocalDate.parse(fechaString, fechaAp); //transformando la
fecha de String a tipo LocalDate
}catch(DateTimeParseException ex){
inputAndOuput.desplegar("Erroror al capturarar la cadena use el
formato(dd-MM-yyyy): "+ex); //mostrando la excepción
}

inputAndOuput.desplegar("\n\n*******Tipo de cuenta deiponibles****** ");

inputAndOuput.desplegar("\n1. <-- Ahorro correiente.");
inputAndOuput.desplegar("\n2. <-- Ahorro Navidad.");
inputAndOuput.desplegar("\n3. <-- plazo fijo.");
inputAndOuput.desplegar("\n\nElija un tipo de cuenta: ");
int tipoCuenta = inputAndOuput.capInt();
inputAndOuput.desplegar("\njAbrir cuenta con: ");
double saldoInicial = inputAndOuput.capDouble();
if(tipoCuenta == 3){ //comparando el tipo de cuenta capturado por el
cliente
while(saldoInicial <= 5000.00){ //cliente con tipo de cuenta 3 solo
debe abrir la cuenta con un saldo inicial mayor a 5000.00
inputAndOuput.desplegar("\nNo se puede abrir una cuenta de plazo
fijo con esa cantidad");
inputAndOuput.desplegar("\nIngrese nuevamente el saldo inicial: ");
saldoInicial = inputAndOuput.capDouble(); //
}
cliente[i] = new Banco(nombreCliente, fecha, saldoInicial,
tipoCuenta); //creando el cliente
}
else{
boolean cerrar = true; //variable control
cliente[i] = new Banco(nombreCliente, fecha, saldoInicial,
tipoCuenta); //crenado el objeto o cuenta o inicializando un objeto de la clase Banco
while(tipoCuenta == 1 && cerrar){ //verifica si la cuenta que se
esta abriendo fue tipo cuenta 1, para aplicar el interés
inputAndOuput.desplegar("\nTaza de interes: ");
double interes = 0;
interes = inputAndOuput.capDouble(); //captura la taza de
interés

if(interes > 0 && interes <= 3){ //comprueba si el interés que pide
el cliente es aceptado por el banco
cliente[i].setTazaInteres(interes); //mandando el interés o
aplicando el interés que tendrá el cliente
cerrar = false;
}
else{
inputAndOuput.desplegar("Taza de interes NO es aceptada por el
Banco.");
}

}//fin while

}
inputAndOuput.desplegar("\n---------------------------------------------
--------\n");
inputAndOuput.desplegar("-----------------------------------------------
------\n");
}//fin del for

boolean salir; //variable de control

 inputAndOuput.desplegar("\n realizar Transacciones o entrar a su cuenta. Presione
la tecla [S]: ");
while(inputAndOuput.capCaracter() == 'S'){ //verifica si el cliente ingresa la
Letra S mayúscula para realizar una transición
salir = true; //inicializamos la variable de control como true
pos = busqueda(cliente, inputAndOuput); //busca el objeto cliente y devuelve
su ubicación
do{ //ejecutando el menu
if(menu(inputAndOuput, cliente, pos) == 6){ //muestra el menú siempre y cuando el
cliente no presione la opción de salir o sea el #6
salir = false; //si introdujo la opción 6 la variable de control tendrá un
valor booleano falso por lo que saldrá directamente del menú.
}//fin si
}while(salir); //comprueba si la variable de control es falso de ser así sale del
menú
inputAndOuput.desplegar("\realizar Transacciones o entrar a su cuenta. Presione la
tecla [S]: ");
} //fin while
}//fin del método principal

/*
* el siguiente método menú lo que realiza es ejecutar la lista de opciones que presenta
* para atender el usuario según sus necesidades, por ejemplo, contiene las opciones
* 1. retirar: le permite al cliente realizar un retiro. De dinero
* 2. depositar: le permite al cliente depositar una cierta cantidad de dinero
* (solo se puede depositar si el tipo de cuenta es cuenta navidad y cuenta ahorro)
* 3. mostrar datos del cliente: devuelve los datos del cliente que se está atendiendo.
* 4. cerrar la cuenta: cierra la cuenta bancaria del cliente.
* 5. ver saldo: le permite al cliente ver el saldo que dispone hasta la fecha.
* 6. Salir: sale del menú y deja de atender al cliente en específico.
*/

public static int menu(InteractiveIO inputAndOuput, Banco cliente[], int pos){

double antiguoSaldo = 0;
boolean salir = true; //variable de control
//lista de opciones que apareceran en pantalla cuando el cliente desee realizar
alguna transacion o consulta
inputAndOuput.desplegar("\n1. Retiro.");
inputAndOuput.desplegar("\n2. Deposito");
inputAndOuput.desplegar("\n3. Mostrar datos de la cuenta bancaria del cliente:
"+cliente[pos].getNombreCliente()+".");
inputAndOuput.desplegar("\n4. Cerrar cuenta bancaria.");
inputAndOuput.desplegar("\n5. VerSaldo.");
inputAndOuput.desplegar("\n6. Salir.");

inputAndOuput.desplegar("\n\nElija una Opcion: ");

int opcion = inputAndOuput.capInt(); // captura la opción que el cliente elija
switch(opcion){ //ejecuta la opción que el cliente elija
case 1: inputAndOuput.desplegar("\t\t\t********Seccion de
retiro**********\n");
//el programa le pregunta al cliente cuanto desea retirar en la
cuenta

inputAndOuput.desplegar("\n".concat(cliente[pos].getNombreCliente()).concat(" ¿cuánto
deseas retirar?\n"));
antiguoSaldo = cliente[pos].getSaldoFinal(); //solamente captura el
saldo final del cliente
if(cliente[pos].retiro(inputAndOuput.capDouble()) && antiguoSaldo ¡= 0){ //
<--- Aquí captura el saldo que ingreso el usuario y además verifica
// si la transacción se puede realizar
inputAndOuput.desplegar("\nLa transacion fue exitosa...");
inputAndOuput.desplegar("\nSu antiguo saldo:"+antiguoSaldo);
// muestra el saldo ante de realizar el deposito
 inputAndOuput.desplegar("\nSu nuevo saldo actual
es:"+cliente[pos].getSaldoFinal()); //muestra el saldo después de realizar el deposito

inputAndOuput.desplegar("********************************************");
}
else{
if(cliente[pos].getTipoCuenta() == 2){ // <--- retorna el tipo de
cuenta para verificar si es de navidad
// para mostrar el mensaje que la cuenta es de navidad y no puede hacer retiro
inputAndOuput.desplegar("La cuenta de ahorro navidad, Aún no
esta diponible para retirar");
}
else{
if(cliente[pos].getTipoCuenta() == 3){// <-- retorna el tipo
de cuenta para verificar si la cuenta es de plazo fijo
inputAndOuput.desplegar("Cuenta de ahorro plazo fijo: no
se a cumplido el plazo fijo de retiro");
else{
inputAndOuput.desplegar("\nEsta cuenta ya está
inhabilitada.");

}
}
}

}
antiguoSaldo = 0; //refrescando la variable de antiguo saldo
break;//case retiro
//deposito
case 2: inputAndOuput.desplegar("\t\t\t**********Secion de
deposito*************");
inputAndOuput.desplegar("\n\nMonto a depositar: "); //le dice al
cliente el monto a depositar
int mes = DiferenciaMes(cliente, pos); //calcula la diferencia de
mes del ultimo deposito con el actual
antiguoSaldo = cliente[pos].getSaldoFinal(); //obtiene el saldo
final del cliente
if(cliente[pos].deposito(inputAndOuput.capDouble()) && antiguoSaldo
¡= 0){ //verifica si el depósito puede realizarse ademas que captura el monto a depositar
if(mes >= 1) //si ha pasado más de un mes se realiza el interés
al cliente
cliente[pos].aplicarInteres(); //aplica el interes al cliente

inputAndOuput.desplegar("\nLa transacion fue exitosa..."); //le

muestra al usuario que el deposito fue exitoso
inputAndOuput.desplegar("\nSu antiguo saldo:"+antiguoSaldo);//
le muestra en la pantalla el saldo antes de realizar el deposito
inputAndOuput.desplegar("\nSu nuevo saldo actual
es:"+cliente[pos].getSaldoFinal());//luego la muestra después del deposito

inputAndOuput.desplegar("\n********************************************");

}
else{
if(cliente[pos].getTipoCuenta() == 3){ //retorna el tipo de
cuenta y verifica si es de plazo fijo si es de plazo fijo muestra el mensaje "plazo fijo:
no puede depositar"
inputAndOuput.desplegar("Cuenta de ahorro plazo fijo: no
puede depositar");
}
else{
inputAndOuput.desplegar("\nEsta cuenta ya estaba
inhabilitada.");
 }
}
antiguoSaldo = 0; //refrescando la variable
mes = 0; //volvemos a poner la variable mes en cero
break;//Deposito

case 3: if(cliente[pos].getSaldoFinal() != 0){ //verifica si la cuenta está cerrada. si el saldo final

es cero es porque la cuenta ya no existe
inputAndOuput.desplegar("\nDatos del cliente:\n");
inputAndOuput.desplegar(cliente[pos].toString()); //basicamente los datos del cliente son
mostrados en pantalla
}
else{
inputAndOuput.desplegar("\nEsta cuenta esta
cerrada..."); //muestra el mensaje de que la cuenta esta cerrada
}
break;

case 4: inputAndOuput.desplegar("*******Cerrando la cuenta

bancaria**********\n\n");
inputAndOuput.desplegar("Saldo actual:
"+cliente[pos].getSaldoFinal());//le muestra el saldo actual del cliente para que
observar cuanto tiene y pueda sacar todo el dinero
inputAndOuput.desplegar("\nSacar todo el dinero: ");
double saldo = cliente[pos].getSaldoFinal(); //obtiene el saldo del
cliente
if(cliente[pos].cerrarCuenta(inputAndOuput.capDouble()) == saldo){ //verifica
el saldo obtenido con saldo que ingrese el cliente si todo resulta exitoso en la clase
banco se cierra la cuenta
inputAndOuput.desplegar("Cuenta cerrada...");
}
else{
if(saldo == 0){ // si el saldo final es cero muestra el mensaje inhabilitada
inputAndOuput.desplegar("\nEsta
cuenta ya estaba inhabilitada.");
}
else{
inputAndOuput.desplegar("la cuenta no puede ser cerrada
aun(ahorro navidad, plazo fijo) ");
}
}

break;
//sección muestra saldo
case 5: if(cliente[pos].getSaldoFinal() != 0)
inputAndOuput.desplegar("Useted dispone de:
"+cliente[pos].getSaldoFinal()); //muestra el saldo actual de la cuenta(fondo)
else
inputAndOuput.desplegar(“Esta cuenta esta cerrada”);
break;

case 6: salir = false; //sale del menú

break;
}

inputAndOuput.desplegar("\n**************************************************************
******\n");
return (opcion); // retorna la opción elegida
}

/*
* retorna la diferencia de mes que hay entre el ultimo deposito
* con el depósito actual:
* Usaremos la clase LocalDate para obtener la fecha del sistema usando unos de sus
métodos (now())
* Usaremos la clase Period para obtener el periodo del mes.
* como argumento le pasamos el cliente [] y la pos (posición)
*/
public static int DiferenciaMes(Banco cliente[], int pos){

LocalDate fechaAhora = LocalDate.now(); //obtenemos la fecha del sistema

LocalDate fechaUltimoDep = cliente[pos].getFechaUltimoDEposito();//retorna de la
clase banco la última fecha de deposito
cliente[pos].setUltimoDeposito(fechaAhora); //actualiza en la clase banco la fecha
del cliente o sea le manda la fecha obtenida por el sistema
Period meses = Period.between(fechaUltimoDep, fechaAhora); //sacamos el periodo del
ultimo deposito con el actual

return(meses.getMonths()); // retornamos la cantidad de meses pasados

}

/*
*básicamente hace la búsqueda del cliente seleccionado
*/
public static int busqueda(Banco cliente[], InteractiveIO inputAndOuput){
inputAndOuput.desplegar("Nombre del cliente a buscar: ");
String nomClient = inputAndOuput.capString(); //captura el cliente a buscar
String nombre = null;
int i,pos=0;
for (i=0; i < cliente.length; i++){ //recorre todas la posiciones de cada objeto
nombre = cliente[i].getNombreCliente(); //obtiene el nombre del cliente para
verificarlo
if(nomClient.equals(nombre)){ //verifica si ambos nombres coinciden de ser
así captura la posición luego de finalizar el ciclo devuelve la posición.
pos = i;
}
}//FIN DEL
return (pos);
}

}//fin de la clase SistemaBanco

Evidencia de la clase Banco.

En las siguientes imágenes observara la clase Banco
La documentación o explicación de la clase Banco son una de las primeras hojas

import java.time.LocalDate;
//import java.text.*;

public class Banco {

//probiedades
private String nombreCliente;
private LocalDate fechApertura;
private double tazaInteres;
 private double saldoInicial;
private int tipoCuenta;
private double saldoFinal;
private LocalDate fechaUltimoDeposito; //listo

//CONSTRUCTOR
Banco(String nombreCliente, LocalDate fechApertura, double saldoInicial, int
tipoCuenta){
this.nombreCliente = nombreCliente;
this.fechApertura =fechApertura;
this.saldoInicial = saldoInicial;
this.tipoCuenta = tipoCuenta;
this.saldoFinal = saldoInicial;
this.fechaUltimoDeposito = fechApertura;
}//fin del constructor

public boolean retiro(double saldoRetirar){

boolean retirado = true;
if(this.tipoCuenta == 1 && saldoRetirar < this.saldoFinal){
this.saldoFinal -= saldoRetirar;
}
else{
if(this.tipoCuenta == 2){
retirado = false;
return (retirado);
}
else{
if(this.tipoCuenta == 3){
retirado = false;
return (retirado);
}
}
}
return (retirado);
}

//realizando el deposito
public boolean deposito(double saldoDep){
boolean depositado = true;
if(this.tipoCuenta == 1){//ahorro corriente
this.saldoFinal += saldoDep;
}
else{
if(this.tipoCuenta == 2){//ahorro navidad
this.saldoFinal += saldoDep;
}
else{
depositado = false;
}
}
return (depositado);
}

//cerrando la cuenta bancaria

public double cerrarCuenta(double saldoTotal){
double saldo = 0;
 if((this.saldoFinal > 0)){
this.saldoInicial = 0;
saldo = this.saldoFinal;
this.saldoFinal -= saldoTotal;
}
else{
if(this.saldoFinal == 0){
saldo = 0;
}
}
return(saldo);
}

//Aplicando Interes
public void aplicarInteres(){
this.saldoFinal = (this.saldoFinal +((this.saldoFinal * this.tazaInteres) / 100));
}

// @Override
public String toString(){
return("Nombre de la Cuenta: "+getNombreCliente()+
"\nTipo de Cuenta: "+getTipoCuenta()+
"\nSaldo final: "+getSaldoFinal()+
"\nSaldo Inicial: "+this.saldoInicial);
}//devuelve datos de la cuenta del cliente

public String getNombreCliente(){

return(this.nombreCliente);
}

public int getTipoCuenta(){

return (this.tipoCuenta);
}

public LocalDate getFechaUltimoDEposito(){

return (this.fechaUltimoDeposito);
}

public LocalDate getFechaApertura(){

return (this.fechApertura);
}

public void setUltimoDeposito(LocalDate fechaUltimoDeposito){

this.fechaUltimoDeposito = fechaUltimoDeposito;
}

public double getSaldoFinal(){

return (this.saldoFinal);
}

public void setTazaInteres(double tazaInteres){

this.tazaInteres = tazaInteres;
}
}//fin de la clase banc
Evidencia de la clase InteractiveIO.
En las siguientes imágenes encontraremos la clase InteractiveIO creada para desplegar y capturar
datos de tipos String, char, double y entero.
Documentacion o los comentarios están marcado de color amarillo

import java.io.*;
public class InteractiveIO {

// definimos el flujo de datos a usar en este caso el teclado

InputStreamReader isrTeclado = new InputStreamReader(System.in);
BufferedReader brGuardar = new BufferedReader(isrTeclado);

InteractiveIO(){ //constructor de la clase

}

public void desplegar(String cadena){ //recibe la cadena a mostrar

System.out.print(cadena);
}

public int capInt(){ //metodo que captura un numero entero

int integer = 0;

try{ //tratamos las excepciones

//capatura en numero como un String y lo transforma un dato entero
integer = Integer.parseInt(brGuardar.readLine());
}catch(IOException e){
//envía este mensaje si el usuario ingresa una letra del alfabeto
System.out.println("Error al capturar dato entero"+e);
}

return (integer); //retorna el numero

}

//capturamos una cadena

public String capString(){
String cadena=""; //inicializamos la variable

try{ //tratamos la excepción

cadena=brGuardar.readLine();//capturamos la cadena y la
devolvemos
}catch(IOException ep){
System.out.println("Error al capturar dato String"+ep);
}

return (cadena);
}
 //método que captura un dato de tipo double(decimal)
public double capDouble(){
double decimal=0;

try{
//capturamos el Dato Como String y lo transformamos a decimal
decimal=Double.parseDouble(brGuardar.readLine());
}catch(IOException ep){
System.out.println("Error al capturar dato de punto
flotante(Decimal)."+ep);
}

return (decimal); //retornamos el dato capturado

}

//metodo que captura un caracter

public char capCaracter(){
String cd; //declaramos un objeto String
char caracter='\0';//declaramos una variable tipo char

try{
cd = brGuardar.readLine(); //capturamos un String
caracter = cd.charAt(0);//del String capturado capturamos la
primera posición o sea la posición 0

}catch(IOException exp){
System.out.print("Error al capturar el caracter"+exp);
}

return (caracter); //retornamos el carácter obtenido.

}
}//fin de la clase InteractiveIO
 Métodos creados por el programador
métodos de la clase Banco
Tabla 2
método
retiro ()
devuelve un boolean, recibe como
argumento un valor de tipo double,
además es público (modificador de
acceso)
deposito () devuelve tipo de dato boolean,
recibe un valor de tipo double como
argumento, además es publico
(modificador de acceso).
método
cerrarCuenta ()
debuleve un tipo de dato double, recibe
como argumento de tipo double, su
modificador de acceso es public
getTipoCuenta ()
devuelve un entero, su modificador de
acceso es public
getNombreCliente ()
devuelve un tipo de dato String
getFechaUltimoDeposito ()
devuelve un tipo de dato LocalDate
getFechaApertura ()
devuelve un tipo de dato LocalDate
uso
Recibe como argumento el saldo que
retira el cliente dependiendo del tipo
de cuenta y el saldo actual que posee
el cliente se realizara el retiro
Recibe como argumento el saldo o
monto que ira a depositar el cliente, si
el tipo de cuenta lo permite se realiza
deposito
uso
Este método recibe el saldo total que
el usuario o cliente debe ingresar para
cerrar la cuenta, el método compara el
saldo final si es mayor a cero, porque
no tiene sentido cerrar una cuenta con
saldo final cero.
Usado para retornar el tipo de cuenta,
del objeto cliente, a la clase principal.
(obtener)
Retorna el nombre del cliente a la
clase principal. (obtener).
Retorna la fecha del ultimo deposito.
(obtener)
Retorna la fecha de apertura de la
cuenta. (obtener)
 aplicarIntere () Multiplicamos el saldo final con la tasa
no devuelve o no retorna ningun valor de interés y dividimos entre el 100% y
es de tipo void ese saldo lo sumamos al saldo final de
la cuenta.

Tabla 4

Método uso
toString () Este método es usado, para devolver
este método devuelve una secuencia de los datos o mostrar los datos del
caracteres o sea un String cliente.

Tabla 5
Método
setUltimoDeposito ()
no retorna ningún valor es void
recibe un argumento de tipo LocalDate
que es la fecha de ultimo deposito.
getSaldoFinal ()
devuelve un tipo de dato double
uso
Actualiza la última fecha del depósito
que realiza el cliente
Obtiene el saldo final del cliente y lo
lleva a la clase principal y lo muestra
al cliente.

Métodos de la clase SistemaBanco.

Tabla 6
método uso
menú () Ejecuta una lista de opciones que puede elegir
Método static, el cliente
devuelve un dato entero.
Recibe como argumentos un objeto de la clase
IntractiveIO para mostrar y capturar datos dntro
de método menú.Tambien recibe también recibe
un arreglo de la clase Banco, además recibe un
dato entero (la ubicación del cliente en el
arreglo)
diferenciaMes () Calcula la diferencia de mes del ultimo deposito
método static que realizo el cliente con la fecha actual que se
retorna un valor de tipo entero obtiene del sistema y saca el periodo que ha
recibe los argumentos como un array de objetos pasado entre esas fechas.
de la clase Banco y la posición como un dato
entero.
Argumentos:
Banco cliente []: contiene el objeto cliente a
calcular la diferencia de mes.
Int pos: posición exacta del cliente al calcular la
diferencia de mes
Búsqueda () Este metodo es usado para hacer la búsqueda
Método static del cliente que se desea, en si este metodo te
 Retorna un dato de tipo entero retorna la ubicación exacta del cliente que va
Los argumentos que recibe son; ser atendido
Banco clientes []: lista de cliente a buscar.
InteractiveIO inputAndOuput: usada para
capturar el cliente que desea buscar

Métodos de la clase InteractiveIO

Esta clase fue creada por el programador y es usada para la entrada y salida de datos.
Tabla 7
método uso
desplegar () Muestra un mensaje por consola.
no retorna ningún valor Usado como método de salida
recibe una cadena de caracteres las cueles son
las que muestra el método por pantalla
capInt () Captura el numero como un String lo transforma
retorna un entero a entero y lo retorna.
no recibe argumentos Usado como método de entrada
capDouble () Captura el numero como un String lo transforma
retorna un dato como punto flotante a double y lo retorna
no recibe argumentos Usado como método de entrada
capCaracter () Captura un String lo transforma obtiene la
retorna un carácter posición 0 de ese carácter y lo retorna
no recibe argumentos Usado como método de entrada
capString () Captura un String y lo retorna
retorna una secuencia de carácter (String) Usado como método de entrada
no recibe argumentos

Clases y métodos definidos por el lenguaje java

Tabla 8
clases metodos
Period between ()
retorna: tipo de dato Period
argumentos: recibe dos son:
fecha de ultimo depósito y la fecha actual
ambas de tipo LocalDate.
Uso: saca el periodo que a pasado entre dos
fechas
getMonths ()
retorna: entero
LocalDate now ():
retorna: tipo de dato LocalDate
argumentos: no recibe.
Uso: devuelve la fecha del sistema.
parse ():
 retorna: un tipo de dato LocalDate.
Argumentos: recibe el formato de la fecha como
DateTimeFormatter, también recibe la fecha
como una cadena
Uso: transformar la fecha de String a LocalDate

Tabla 9
clases metodos
DateTimeFormatter ofParttern ()
retorna: un tipo de dato DateTimeFormatter
argumento: recibe como argumento un formato
de fecha como cadena.
Uso: obtener un formato de la fecha (dd-MM-
yyyy).
BufferedReader readLine ()
retorna: una cadena o captura una cadena
argumentos: no recibe
uso: capturar una cadena por el teclado
InputStreamReader ----------------------------------------------------------------

Constructores usados
Tabla 10
constructores uso
Banco (String name, LocalDate fechaA, double Inicializa un objeto de la clase Banco
saldo, int cuenta)
InteractiveIO () Construye el objeto de entrada y salida de datos
InputStreamReader (System.in) Definiendo el flujo de datos de entrada
BufferedReader(Objeto teclado)
 Datos de prueba
Tabla 11
Nombre del cliente Leonardo
Fecha de apertura 02-10-2018
Fecha de cierre Toma la del sistema
Saldo inicial 300
Saldo final 1000
Tipo de cuenta 1
Interés 3.0
Nota: tipo de datos que prueba que el programa funciona bien al abrir una cuenta 1 (ahorro
corriente), puede depositar y retirar

Tabla 12
Nombre del cliente Juan
Fecha de apertura 02-09-2018
Fecha de cierre Toma la del sistema
Saldo inicial 700
Saldo final 900
Tipo de cuenta 2
Nota: tipo de datos que prueba que el programa funciona bien al abrir una cuenta 2 (navidad), solo
puede depositar

Tabla 13
Nombre del cliente Andrés
Fecha de apertura 25-08-2019
Fecha de cierre Toma la del sistema
Saldo inicial 700
Saldo final La cuenta tipo 3 no lo permite
Tipo de cuenta 3
Nota: los datos de prueba de la tabla 13 vemos que el tipo de cuenta es 3 (plazo fijo), por lo que se
sabe que el saldo inicial debe ser mayor a 5000.00 dólares y la tabla13 muestra que saldo inicial es
de 700. Esto se hizo para probar la restricción que trata este caso. No puede tocar el dinero
Evidencia de ejecución del programa