Código fuente de recarga de cuenta en línea
Acceso de cadena protegida
Nombre de cadena protegida;
Dinero doble protegido;
Cuenta pública (Acceso de cadena, Cadena nombre){
this(accId, nombre, 0);
}
Cuenta pública (String accId, nombre de cadena, doble dinero){
this.accId = accId
this.name = nombre
this.money = dinero;
}
público void save money(double money){
if (money lt= 0){
System.out.println("Depósito La cantidad debe ser mayor que 0 ");
}
this . dinero = dinero;
System.out.println("Depósito exitoso");
}
public double getMoney(doble dinero){
if (money lt= 0){
System.out.println("Retirar dinero La cantidad debe ser mayor que 0 "
Devuelve 0;
}
Si (this.money lt=money){
System .out.println( "Saldo insuficiente, no se puede retirar dinero");
Devuelve 0;
}
this.money -=money;
System.out.println("Retiro exitoso");
Devolver el dinero;
}
getBalance público doble(){
Devolver el dinero;
}
Doble protegido getOverdraft(){
Devolución 0;
}
//El método igual se implementa para que la comparación de listas pueda ser correcta.
@override
Booleano público es igual a (objeto objeto){
if(obj == null){
devuelve falso
}
if(this == obj){
return true
}
if(objeto de cuenta Ejemplo ){
Devuelve esto. accid es igual a(((Cuenta)obj).accId);
}
Devuelve falso
}
@override
Cadena pública toString() {
Devuelve "cuenta =" accId ", nombre =" nombre ", saldo = " dinero ;
}
}
Banco de clase pública{
// La cuenta implementa el método igual para que la lista se pueda encontrar correctamente.
Lista de distribución personal ltAccountsgtusersAccounts
Banco público(){
usersAccounts = new ArrayList ltAccountsgt();
}
public void addAccount(Cuenta de cuenta){
if(cuentas de usuarios. Contiene (cuenta)){
System.out.println("Error al agregar, no se puede agregar el misma cuenta");
Regresar;
}
cuenta de usuarios . add(cuenta);
}
Cuenta booleana pública(Cuenta de cuenta){
recuentos de usuarios devueltos eliminar(cuenta);
}
Cuenta booleana pública (cuenta de cadena) {
return delAccount(nueva cuenta(accId, null));
}
Cuenta pública booleana existente(Cuenta Cuenta){
Devolver recuentos de usuarios. contiene (cuenta);
}
existAccount booleano público (String accId) {
Devuelve existAccount (nueva cuenta (accId, nulo) );
}
Cuenta pública getAccount(String accId){
regresar recuentos de usuarios get(recuentos de usuarios . índice de(nueva cuenta( accId, null )));
}
public double getAllMoney() {
//Independientemente del desbordamiento o no, solo suma los saldos de todos los usuarios.
Resultado doble = 0;
for(Cuenta Cuenta: recuentos de usuarios){
resultado = cuenta obtener saldo(); >}
Devuelve el resultado;
}
public double getAllOverdraft() {
//Independientemente de si se desborda
Resultado doble = 0;
for(Cuenta Cuenta: recuentos de usuarios){
resultado = cuenta obtener sobregiro();
}
Devolver resultados;
}
public int getAccountNum() {
Devolver recuentos de usuarios();
}
public int getCreditAccountNum(){
int num = 0;
for(Cuenta Cuenta: recuentos de usuarios){
// El rendimiento de instancia de no es tan rápido como el método simple.
Instancia de cuenta de CreditAccount) {
num
}
}
Cantidad devuelta;
p>
}
public int getSavingAccountNum(){
int num = 0;
for(Cuenta Cuenta: recuentos de usuarios ){
Instancia de cuenta de SavingAccount){
num;
}
}
Cantidad devuelta;
}
Lista pública cuenta lt gtgetAllAccount() {
Devolver cuentas de usuarios
}
}
cuenta extendida de cuenta de crédito de clase pública {
sobregiro doble privado;
cuenta de crédito pública (String accId, nombre de cadena) {
super(accId, nombre);
este .overdraft = 1000;
}
cuenta de crédito pública (String accId, String nombre, doble dinero){
Esta (cuenta de cuenta, nombre, dinero, 1000);
}
cuenta de crédito pública (cuenta de cadena, nombre de cadena, doble dinero, doble sobregiro) {
Super (accId, nombre, dinero);
este .overdraft = sobregiro
}
@override
doble público; getMoney(doble dinero){
If (money lt= 0){
System.out.println("El monto del retiro debe ser mayor que 0 ");
Return 0;
}
if(this.money overdraftlt=money){
System.out.println("Saldo insuficiente, no se puede retirar dinero ");
Devuelve 0;
}
this.money -=money;
System.out.println("Retiro exitoso");
Devolver el dinero;
}
@Override
Doble público getOverdraft(){
Devolver el sobregiro ;
}
@Override
Cadena pública toString() {
Devolver "account =" accId " , nombre="nombre", saldo="dinero", sobregiro="sobregiro;
}
}
Cuenta pública de ahorro de clase extiende Cuenta {
cuenta de ahorro pública(String ACCId, String nombre){
super(accId, nombre);
}
cuenta de ahorro pública (String ACCId , Nombre de cadena, dinero doble) {
super(accId, nombre, dinero);
}
@OVERRIDE
getMoney público doble(dinero doble){
return super.getMoney(dinero);
}
@Override
Público doble getOverdraft() {
return super . get overdraft();
}
}
Prueba de clase pública{
Banco privado estático Banco = nuevo Banco();
Público estático void main(String[ ] args) {
prueba . gen cuenta();
//Abrir una cuenta
cuenta a 1 = nueva cuenta de crédito(" 1 ", " 1 " , 200, 2000);
Cuenta a2 = nueva CuentaAhorro("2", "2", 300);
Cuenta a3 = nueva CuentaAhorro("3", " 3" , 400);
Cuenta a4 = nueva Cuenta de Crédito("4", "4", 500, 2000);
Cuenta a5 = nueva Cuenta de Crédito("4", " 5" , 600, 2000); //Cuenta 4 veces
banco . agregar cuenta(a 1);
banco . agregar cuenta(a2);
banco agregar cuenta(a3);
banco agregar cuenta(a4);
banco agregar cuenta(a5);
showNowAccount();
p>
//Cancelación de cuenta
banco cuenta(" 1 ");
banco cuenta(" 2 "); p>
showNowAccount( );
//Depósito
if(banco . existe cuenta(" 3 "){
cuenta = banco . get cuenta(" 3 ");
ACC ahorrar dinero(100);
}
mostrarAhoraCuenta(); Retirar dinero
if(banco . existe cuenta(" 3 "){
cuenta = banco . obtener cuenta(" 3 ");
sistema . out . println(" saldo = " ACC . obtener saldo());
ACC . obtener dinero(100);
sistema println(" saldo = " ACC . ());
ACC . getmoney(1000);
system out . }
if(banco .exis
t cuenta(" 4 "){
cuenta = banco . obtener cuenta(" 4 ");
sistema println(" saldo = " ACC . obtener saldo(). );
ACC . getmoney(100);
sistema . println(" saldo = " ACC . obtener saldo()); getmoney(1000);
sistema . println(" saldo = " ACC . obtener saldo()
ACC . >sistema . println(" saldo = " ACC . obtener saldo());
}
sistema salida . >
sistema . println(banco . getall money());
sistema . println(banco . getalloverdraft());
sistema . (banco . getcreditaccountnum());
sistema . println(banco . getservedaccountnum());
}
GenAccount nula estática pública(){
cadena s = " 1000 0000 0000 000 ";
Cuenta a = vacía
for(int I = 1; i lt11; i ) {
if ((i amp2) == 0){
A = nueva cuenta de crédito(s String.valueOf(i), cadena "cuenta" .valor de(I));
} En caso contrario {
A = nueva cuenta de ahorros(s String.valueOf(i), cadena "cuenta". valor de(I));
}
banco . agregar cuenta(a);
}
}
Núcleo estático público showNowAccount(){
for(Cuenta Cuenta: banco . getallaccount()){
sistema out . println(cuenta);
}
}
}