Si hay que usar un arreglo "primitivo", tenemos el inconveniente de que ha de tener un tamaño fijo.
Por eso el programa lo primero que tendrá que hacer es preguntar cuantas cuentas queremos gestionar, es decir, qué tamaño le vamos a dar a ese arreglo.
Tener un tamaño fijo significa que, en realidad, no podemos añadir o borrar Cuentas al arreglo.
Si por ejemplo decimos que queremos gestionar 20 cuentas, pues entonces el arreglo SIEMPRE va a tener 20 Cuentas.
Sin embargo, esas 20 Cuentas puede que tengan valor null o que tengan un objeto Cuenta instanciado.
Y eso es lo que vamos a usar para saber si hay espacio o no para "añadir" o "borrar" cuentas.
Si el arreglo tiene alguna posición con valor null, es que hay espacio para una nueva Cuenta.
Si no hay ningún valor null, es que no se aceptan nuevas cuentas.
Cuando queremos "borrar" una cuenta, lo que haremos será darle valor null.
Bien, lo primero es escribir la clase Cuenta. Yo la he escrito así:
public class Cuenta {
private int numeroCuenta;
private String titular;
private double saldo;
public Cuenta(int numeroCuenta, String titular, double saldo) {
this.numeroCuenta = numeroCuenta;
this.titular = titular;
this.saldo = saldo;
}
public int getNumeroCuenta() {
return numeroCuenta;
}
public void depositar(double monto) {
saldo += monto;
}
public boolean retirar(double importe) {
if (importe > saldo)
return false;
else {
saldo -= importe;
return true;
}
}
@Override
public String toString() {
return String.format("Nº Cuenta: %s, Titular: %s, Saldo: %s", numeroCuenta, titular, saldo);
}
}Le he puesto un get al atributo "número de cuenta" porque será el valor que necesitaremos para buscar una cuenta en concreto.
Bueno, la clase de la aplicación principal.
Declararemos como atributo un arreglo de clase Cuenta, sin inicializar.
Al comenzar el programa, preguntaremos la cantidad de cuentas a gestionar y con esa respuesta ya podremos inicializar el arreglo dándole un tamaño.
En ese momento, el arreglo estará lleno de valores null, es decir, no hay cuentas creadas.
Entonces comenzamos un bucle, donde mostraremos un menú y recogeremos la opción elegida por el usuario.
Con un switch analizaremos la opción escogida. Para cada opción llamaremos a un método que se encargará de cumplir con la opción solicitada.
El bucle termina cuando se escoge la opción de "terminar.
Mira, esta sería la estructura del programa principal, falta escribir los métodos, que lo veremos después:
import javax.swing.JOptionPane;
public class Banco {
private static Cuenta[] cuentas; //Arreglo de objetos Cuenta
public static void main(String[] args) {
//Empezamos preguntando cuantas cuentas queremos gestionar
String cantidad = JOptionPane.showInputDialog(null, "¿Cuántas cuentas bancarias quiere gestionar",
"Iniciar Banco", JOptionPane.QUESTION_MESSAGE);
//Inicialiamos el arreglo con la respuesta
cuentas = new Cuenta[Integer.parseInt(cantidad)];
//Comienza menu
String opcion = "";
do {
//Pedimos opcion
opcion = JOptionPane.showInputDialog(null, MENU, "Menú Banco", JOptionPane.PLAIN_MESSAGE);
//Analizamos opcion escogida
switch(opcion) {
case "1":
crearCuenta();
break;
case "2":
depositar();
break;
case "3":
retirar();
break;
case "4":
consultarCuenta();
break;
case "5":
borrarCuenta();
break;
case "6":
consultarTodas();
break;
case "7":
JOptionPane.showMessageDialog(null, "FIN DEL PROGRAMA", "Menú Banco",
JOptionPane.INFORMATION_MESSAGE);
break;
default:
JOptionPane.showMessageDialog(null, "Opción equivocada", "Menú Banco", JOptionPane.ERROR_MESSAGE);
}
}while(!opcion.equals("7"));
}
private static void crearCuenta() {
}
private static void depositar() {
}
private static void retirar() {
}
private static void consultarCuenta() {
}
private static void borrarCuenta() {
}
private static void consultarTodas() {
}
//String con las opciones del menu para mostrar en el JOptionPane
private static final String MENU = "1.- Crear Cuenta\n2._ Depositar\n3.- Retirar\n4.- Consultar Cuenta"
+ "\n5.- Borrar Cuenta\n6.- Consultar Todas\n7.- TERMINAR";
}
Vamos a ver el primer método, crear una cuenta.
Primero hay que comprobar si hay una posición libre en el arreglo.
Así que lo recorremos buscando un valor null, si lo encontramos, guardamos esta posicion en una variable.
Si no hemos encontrado una posición libre, pues informamos y aquí se acaba el método.
Pero si tenemos una posición libre, pues ahora pedimos datos para crear una nueva Cuenta y la insertamos en dicha posición:
private static void crearCuenta() {
//Primero buscamos una posición vacía (null) en el arreglo
int posicion = -1;
for (int i = 0; i < cuentas.length; i++)
if (cuentas[i] == null) {
posicion = i; //Hemos encontrado un hueco vacío donde crear una cuenta
break; //Finalizamos la búsqueda
}
//Comprobamos si hemos encontrado una posición disponible
if (posicion == -1) //No hay disponible, el arreglo está lleno de Cuentas
JOptionPane.showMessageDialog(null, "No hay espacio para una nueva cuenta", "Crear Cuenta",
JOptionPane.WARNING_MESSAGE);
else {
//En la variable posicion tenemos la dirección donde colocar una nueva Cuenta, pedimos datos
String numCuenta = JOptionPane.showInputDialog(null, "Nº de Cuenta:", "Crear Cuenta", -1);
String titular = JOptionPane.showInputDialog(null, "Nombre del Titular:", "Crear Cuenta", -1);
String saldo = JOptionPane.showInputDialog(null, "Saldo inicial:", "Crear Cuenta", -1);
//Tenemos datos, creamos nueva Cuenta en la posicion indicada
cuentas[posicion] = new Cuenta(Integer.parseInt(numCuenta), titular, Double.parseDouble(saldo));
JOptionPane.showMessageDialog(null, "Nueva Cuenta registrada", "Crear Cuenta",
JOptionPane.INFORMATION_MESSAGE);
}
}
Veamos otro método, por ejemplo, la opción 4 para consultar una cuenta.
Aquí lo primero es pedir el nº de cuenta que se quiere consultar.
Luego, se recorre el arreglo buscando una cuenta que coincida con el número indicado.
Ojo, las posiciones null hay que evitarlas, si intentamos comparar algo con ellas, se producirá una excepción.
Solo haremos comparaciones si NO es una posición null
Si encontramos la cuenta que buscamos, podemos referenciarla en otra variable Cuenta, previamente declarada.
Cuando termine la búsqueda, comprobamos si tenemos algo referenciado en esa variable Cuenta.
Si no hay nada (null) es que no existe ninguna cuenta con el número que nos han dado.
En cambio, si tiene un objeto referenciado, pues es que hemos encontrado la cuenta consultada y mostramos en pantalla los datos que proporciona su método toString()
private static void consultarCuenta() {
//Preguntamos número de cuenta a consultar
int numCuenta = Integer.parseInt(JOptionPane.showInputDialog(null, "Nº de cuenta:",
"Consultar Cuenta", JOptionPane.QUESTION_MESSAGE));
//Buscamos con un FOR EACH en el arreglo la Cuenta que buscamos comparando los números de cuenta
//MUCHO CUIDADO con las posiciones null, no debemos intentar comparar nada en ellas
Cuenta buscar = null;
for (Cuenta cuenta: cuentas)
if (cuenta != null) { //Solo comparamos con posiciones que NO son null
if (cuenta.getNumeroCuenta() == numCuenta) {
buscar = cuenta; //Hemos encontrado la cuenta que buscamos.
break; //Dejamos de buscar
}
}
//Comprobamos si hemos encontrado algo
if (buscar == null) //No, no hemos encontrado nada
JOptionPane.showMessageDialog(null, "No hay ninguna cuenta con el nº: " + numCuenta,
"Consultar Cuenta", JOptionPane.WARNING_MESSAGE);
else
JOptionPane.showMessageDialog(null, "Datos de la cuenta:\n" + buscar,
"Consultar Cuenta", JOptionPane.INFORMATION_MESSAGE);
}
Bien, a partir de aquí, intenta continuar tú.
Comprueba que entiendes lo que he explicado, pregunta lo que necesites y a ver si lo puedes poner en práctica para completar el resto de métodos.
Haz lo que puedas, no te preocupes por equivocarte o atascarte (es la única forma de aprender). Llega hasta donde te sea posible, publícalo aquí y te ayudamos a completar.
Un saludo.
Tema: código Java programa aplicación cuenta banco depósitos saldo retirar JOptionPane (Leído 5297 veces)
RSS -
WAP2