Sistema bancario

Fa parte della sezione Programmazione orientata agli oggetti del percorso Java di Coddy. Lezione 85 di 87.

Questa sfida ti chiede di creare un Sistema bancario che modelli operazioni finanziarie del mondo reale utilizzando i principi OOP.

Il tuo sistema dovrebbe gestire diversi tipi di conto, come SavingsAccount e CheckingAccount, entrambi estensioni di una classe base Account. Ogni tipo di conto ha comportamenti specifici: i conti di risparmio potrebbero maturare interessi, mentre i conti correnti potrebbero avere una protezione dallo scoperto.

Pensa a come modellare le transazioni. Un’interfaccia come Transactable potrebbe definire metodi per deposit() e withdraw(). Valuta l’uso di eccezioni personalizzate come InsufficientFundsException per gestire con eleganza le operazioni non valide.

Una classe Bank potrebbe gestire più conti e clienti, dimostrando la composizione. Potresti applicare il pattern Factory per creare diversi tipi di conto oppure usare il pattern Observer per notificare ai clienti le modifiche ai conti.

Concentrati sull’incapsulamento per proteggere i dati sensibili come i saldi e i numeri di conto, e usa il polimorfismo per elaborare in modo uniforme i diversi tipi di conto.

Sfida

Facile

Costruiamo un sistema bancario completo che dimostri la tua padronanza dei principi OOP! Creerai un sistema con diversi tipi di conto, gestione delle transazioni e gestione appropriata delle eccezioni: il tutto organizzato in più file.

Organizzerai il codice in sette file:

Transactable.java: crea un'interfaccia che definisce il contratto per le operazioni finanziarie. Dovrebbe dichiarare i metodi deposit(double amount) e withdraw(double amount), entrambi con valore di ritorno booleano per indicare il successo.
InsufficientFundsException.java: crea un'eccezione personalizzata che estende Exception. Il costruttore dovrebbe accettare l'importo del prelievo tentato e il saldo corrente, creando un messaggio nel formato Insufficient funds: attempted [amount], available [balance].
Account.java: crea una classe base astratta che rappresenti un qualsiasi conto bancario. Includi campi privati per accountNumber (String) e balance (double), un costruttore che inizializzi entrambi, getter appropriati, un setter protetto per il saldo (così che le sottoclassi possano modificarlo) e un metodo astratto getAccountType() che restituisca una String. Implementa un metodo getDetails() che restituisca "[accountNumber] ([accountType]): $[balance]" con il saldo formattato a 2 cifre decimali.
SavingsAccount.java: crea una classe che estenda Account e implementi Transactable. Aggiungi un campo privato per interestRate (double). Il costruttore accetta accountNumber, saldo iniziale e interestRate. Implementa getAccountType() in modo che restituisca "Savings". Per deposit(), aggiungi l'importo al saldo e restituisci true. Per withdraw(), se l'importo supera il saldo, restituisci false; altrimenti sottrai l'importo e restituisci true. Aggiungi un metodo applyInterest() che aumenti il saldo di balance * interestRate (il tasso è memorizzato come frazione, quindi 0.05 significa 5%).
CheckingAccount.java: crea una classe che estenda Account e implementi Transactable. Aggiungi un campo privato per overdraftLimit (double). Il costruttore accetta accountNumber, saldo iniziale e overdraftLimit. Implementa getAccountType() in modo che restituisca "Checking". Per deposit(), aggiungi l'importo e restituisci true. Per withdraw(), consenti il prelievo se l'importo è minore o uguale al saldo più overdraftLimit; restituisci false se supera questo limite.
Bank.java: crea una classe che gestisca i conti usando un ArrayList. Includi i metodi:
- addAccount(Account account) - aggiunge un conto alla banca
- findAccount(String accountNumber) - restituisce l'Account o null se non viene trovato
- transfer(String fromAccount, String toAccount, double amount) - trasferisce denaro tra conti, lanciando InsufficientFundsException se il conto di origine non dispone di fondi sufficienti. In caso di successo, restituisce "Transferred $[amount] from [fromAccount] to [toAccount]"
- getTotalDeposits() - restituisce la somma dei saldi di tutti i conti
Main.java: crea il tuo sistema bancario! Riceverai una stringa di comandi separati da virgole:
- SAVINGS:accountNumber:balance:interestRate
- CHECKING:accountNumber:balance:overdraftLimit
- DEPOSIT:accountNumber:amount
- WITHDRAW:accountNumber:amount
- TRANSFER:fromAccount:toAccount:amount
- INTEREST:accountNumber
Elabora ogni comando e stampa:
- SAVINGS/CHECKING: Account created: [accountNumber]
- DEPOSIT: Deposited $[amount] to [accountNumber]
- WITHDRAW: Withdrew $[amount] from [accountNumber] in caso di successo, oppure Withdrawal failed: [accountNumber]
- TRANSFER: stampa il messaggio di successo oppure Transfer failed: [exception message]
- INTEREST: Interest applied to [accountNumber]
Dopo tutti i comandi, stampa --- Bank Summary --- seguito dai dettagli di ogni conto (usando getDetails()) e infine Total deposits: $[total] formattato a 2 cifre decimali.

Riceverai un input: la stringa di comandi separati da virgole.

Ad esempio, con l'input SAVINGS:SAV001:1000.00:0.05,CHECKING:CHK001:500.00:200.00,DEPOSIT:SAV001:250.00,WITHDRAW:CHK001:600.00,TRANSFER:SAV001:CHK001:100.00,INTEREST:SAV001, il tuo output sarebbe:

Account created: SAV001
Account created: CHK001
Deposited $250.00 to SAV001
Withdrew $600.00 from CHK001
Transferred $100.00 from SAV001 to CHK001
Interest applied to SAV001
--- Bank Summary ---
SAV001 (Savings): $1207.50
CHK001 (Checking): $0.00
Total deposits: $1207.50

Nota come il conto corrente consenta il prelievo di $600 nonostante abbia un saldo di soli $500: ecco la protezione dallo scoperto in azione! Il conto di risparmio matura il 5% di interessi sul saldo dopo il trasferimento. Questa sfida combina ereditarietà, interfacce, polimorfismo, eccezioni personalizzate ed incapsulamento in un'applicazione bancaria realistica!

Provalo tu

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        
        // TODO: Crea un'istanza di Bank
        
        // TODO: Dividi input in corrispondenza delle virgole per ottenere i singoli comandi
        
        // TODO: Elabora ogni comando:
        // - SAVINGS:accountNumber:balance:interestRate -> Crea un SavingsAccount e stampa "Account created: [accountNumber]"
        // - CHECKING:accountNumber:balance:overdraftLimit -> Crea un CheckingAccount e stampa "Account created: [accountNumber]"
        // - DEPOSIT:accountNumber:amount -> Effettua un deposito e stampa "Deposited $[amount] to [accountNumber]"
        // - WITHDRAW:accountNumber:amount -> Effettua un prelievo e stampa la conferma o "Withdrawal failed: [accountNumber]"
        // - TRANSFER:fromAccount:toAccount:amount -> Effettua un trasferimento e stampa la conferma o "Transfer failed: [exception message]"
        // - INTEREST:accountNumber -> Applica gli interessi e stampa "Interest applied to [accountNumber]"
        
        // TODO: Dopo tutti i comandi, stampa "--- Bank Summary ---"
        
        // TODO: Stampa i dettagli di ogni conto usando getDetails()
        
        // TODO: Stampa "Total deposits: $[total]" formattato con 2 cifre decimali
    }
}