Ok.
Vayamos por partes:
Desarrollar un programa que modele una cuenta bancaria que tiene los siguientes atributos, que deben ser de acceso protegido:
• Saldo, de tipo float.
• Número de ingresos con valor inicial cero, de tipo int.
• Número de retiros con valor inicial cero, de tipo int.
• Tasa anual (porcentaje), de tipo float.
• Comisión mensual con valor inicial cero, de tipo float.
La clase Cuenta tiene un constructor que inicializa los atributos saldo y tasa anual con valores pasados como parámetros. La clase
Cuenta tiene los siguientes métodos:
• Ingresar una cantidad de dinero en la cuenta actualizando su saldo.
• Retirar una cantidad de dinero en la cuenta actualizando su saldo. El valor a retirar no debe superar el saldo.
• Calcular el interés mensual de la cuenta y actualiza el saldo correspondiente.
• Extracto mensual: actualiza el saldo restándole la comisión mensual y calculando el interés mensual correspondiente (invoca el
método anterior).
• Imprimir: muestra en pantalla los valores de los atributos.
Esta sería la clase
Cuenta, los métodos para calcular el interes mensual y el extracto mensual los he dejado vacíos porque la verdad no me queda claro como se supone que ha de calcularse con un atributo que se llama tasa "anual". Por otro lado, es algo irrelevante, ya que aquí lo que importa es practicar herencias de clases.
public class Cuenta {
protected float saldo;
protected int numIngresos;
protected int numRetiros;
protected float tasaAnual;
protected float comiMensual;
public Cuenta(float saldo, float tasaAnual) {
this.saldo = saldo;
this.tasaAnual = tasaAnual;
numIngresos = 0;
numRetiros = 0;
comiMensual = 0;
}
public void ingresar(float cantidad) {
saldo += cantidad;
numIngresos++;
System.out.println("Ingreso realizado");
}
public void retirar(float cantidad) {
if (cantidad > saldo)
System.out.println("No hay fondos para cubrir la retirada");
else {
saldo -= cantidad;
numRetiros++;
System.out.println("Retiro realizado");
}
}
public void calcularInteresMensual() {
}
public void extractoMensual() {
}
public void imprimir() {
System.out.printf("\nSaldo: %.2f\n", saldo);
System.out.println("Numero Ingresos: " + numIngresos);
System.out.println("Numero Retiros: " + numRetiros);
System.out.printf("Tasa Anual: %.2f%%\n", tasaAnual);
System.out.printf("Comision Mensual: %.2f\n\n", comiMensual);
}
}Siguiente:
Cuenta de ahorros: posee un atributo para determinar si la cuenta de ahorros está activa (tipo boolean). Si el saldo es menor a
100€, la cuenta está inactiva, en caso contrario se considera activa. Los siguientes métodos se redefinen:
1. Ingresar: se puede ingresar dinero si la cuenta está activa. Debe invocar al método heredado.
2. Retirar: es posible retirar dinero si la cuenta está activa. Debe invocar al método heredado.
3. Extracto mensual: si el número de retiros es mayor que 4, por cada retiro adicional, se cobra 1.5€ como comisión
mensual. Al generar el extracto, se determina si la cuenta está activa o no con el saldo.
4. Un nuevo método imprimir que muestra en pantalla el saldo de la cuenta, la comisión mensual y el número de
transacciones realizadas (suma de cantidad de consignaciones y retiros).
Pues esta es la clase
CuentaAhorros, añadiendo nuevo atributo y sobre escribiendo los métodos según se pide:
public class CuentaAhorros extends Cuenta {
private boolean esActiva;
public CuentaAhorros(float saldo, float tasaAnual) {
super(saldo, tasaAnual);
esActiva = saldo >= 100;
}
@Override
public void ingresar(float cantidad) {
if (esActiva)
super.ingresar(cantidad);
else
System.out.println("Ingreso no es posible. Cuenta inactiva");
}
@Override
public void retirar(float cantidad) {
if (esActiva) {
super.retirar(cantidad);
esActiva = saldo >= 100; //Tras retirar puede quedar inactiva
}
else
System.out.println("Retiro no es posible. Cuenta inactiva");
}
@Override
public void extractoMensual() {
}
@Override
public void imprimir() {
System.out.printf("\nSaldo: %.2f\n", saldo);
System.out.printf("Comision Mensual: %.2f\n", comiMensual);
System.out.println("Total Transacciones: " + (numIngresos + numRetiros) + "\n");
}
}Siguiente:
Cuenta corriente: posee un atributo de sobregiro, el cual se inicializa en cero. Se redefinen los siguientes métodos:
• Retirar: se retira dinero de la cuenta actualizando su saldo. Se puede retirar dinero superior al saldo. El dinero que se debe
queda como sobregiro.
• Ingresar: invoca al método heredado. Si hay sobregiro, la cantidad consignada reduce el sobregiro.
• Extracto mensual: invoca al método heredado.
• Un nuevo método imprimir que muestra en pantalla el saldo de la cuenta, la comisión mensual, el número de
transacciones realizadas (suma de cantidad de consignaciones y retiros) y el valor de sobregiro.
Pues clase
CuentaCorriente:
public class CuentaCorriente extends Cuenta {
private float sobreGiro;
public CuentaCorriente(float saldo, float tasaAnual) {
super(saldo, tasaAnual);
sobreGiro = 0;
}
@Override
public void retirar(float cantidad) {
saldo -= cantidad;
if (saldo < 0) {
sobreGiro = saldo;
saldo = 0;
}
System.out.println("Retiro realizado");
}
@Override
public void ingresar(float cantidad) {
//¿Hay sobregiro?
if (sobreGiro < 0) { //Sí lo hay
sobreGiro += cantidad;
/*
* Si ahora sobreGiro tiene ahora valor positivo
* es que ha quedado cancelado (vuelve a 0)
* y la cantidad positiva es la que se ingresa al saldo
*/
if (sobreGiro > 0) {
super.ingresar(sobreGiro);
sobreGiro = 0; //Vuelve a 0
}
else
System.out.println("Ingreso realizado");
}
else //No hay sobregiro
super.ingresar(cantidad);
}
@Override
public void imprimir() {
System.out.printf("\nSaldo: %.2f\n", saldo);
System.out.printf("Comision Mensual: %.2f\n", comiMensual);
System.out.println("Total Transacciones: " + (numIngresos + numRetiros));
System.out.printf("Sobregiro: %.2f\n\n", sobreGiro);
}
}Por último:
Realizar un método main que implemente un objeto Cuenta de ahorros y llame a los métodos correspondientes
Aquí un main, donde llamo a los métodos básicos para comprobar que se puede retirar y operar con la cuenta, hasta que se queda inactiva por la cantidad de saldo.
No llamo a los métodos que no he sabido escribir.
public class Main {
public static void main(String[] args) {
CuentaAhorros ahorros = new CuentaAhorros(2300, 2.6f);
ahorros.imprimir();
ahorros.retirar(2200);
ahorros.imprimir();
ahorros.retirar(100);
ahorros.imprimir();
ahorros.ingresar(1500);
}
}Bueno, a parte de esos cálculos que no he entendido como hacer, en lo que respecta a la herencia no ha habido ningún problema.
Para el "main" nos piden crear un objeto de clase
CuentaAhorros, que hereda de
Cuenta.
No necesitas nada de la otra clase
CuentaCorriente para cumplir con el enunciado.
Ya que la has escrito, puedes crear también un objeto de esa clase y comprobar que funciona. Pero el enunciado no lo exige.
Te han pedido que la escribas, pero no que la pongas a prueba.
Quizás esto es lo que te estaba confundiendo, que te hayan hecho crear algo para luego no probarlo...
...y quizás pensaste que en realidad sí debías probarla, pero solo a través de una de la clases hijas.
Lo cuál es imposible, como ya comenté antes.
Según el enunciado, no es necesario comprobar la clase
CuentaCorriente.
Puedes hacerlo si quieres, pero tendrás que crear un segundo objeto que pertenezca a dicha clase.
Espero que se hayan aclarados tus dudas.
Un saludo.
Tema: Herencia Java (Leído 2422 veces)
RSS -
WAP2