Système bancaire

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy. Leçon 85 sur 87.

Ce défi vous demande de créer un système bancaire qui modélise des opérations financières du monde réel à l’aide des principes de la POO.

Votre système devrait gérer différents types de comptes, comme SavingsAccount et CheckingAccount, qui étendent tous deux la classe Account de base. Chaque type de compte possède des comportements uniques : les comptes d’épargne peuvent produire des intérêts, tandis que les comptes chèques peuvent bénéficier d’une protection contre les découverts.

Réfléchissez à la manière de modéliser les transactions. Une interface comme Transactable pourrait définir des méthodes pour deposit() et withdraw(). Envisagez d’utiliser des exceptions personnalisées telles que InsufficientFundsException pour gérer les opérations invalides avec élégance.

Une classe Bank peut gérer plusieurs comptes et clients, illustrant la composition. Vous pourriez appliquer le modèle Factory pour créer différents types de comptes, ou utiliser le modèle Observer pour informer les clients des changements de compte.

Concentrez-vous sur l’encapsulation pour protéger les données sensibles comme les soldes et les numéros de compte, et utilisez le polymorphisme pour traiter uniformément différents types de comptes.

Défi

Facile

Construisons un système bancaire complet qui démontre votre maîtrise des principes de la POO ! Vous créerez un système avec différents types de comptes, la gestion des transactions et une gestion appropriée des exceptions, le tout organisé sur plusieurs fichiers.

Vous organiserez votre code sur sept fichiers :

Transactable.java : Créez une interface qui définit le contrat pour les opérations financières. Elle doit déclarer les méthodes deposit(double amount) et withdraw(double amount), qui renvoient toutes deux un booléen indiquant leur réussite.
InsufficientFundsException.java : Créez une exception personnalisée qui étend Exception. Le constructeur doit accepter le montant du retrait tenté et le solde actuel, en créant un message au format Insufficient funds: attempted [amount], available [balance].
Account.java : Créez une classe de base abstraite représentant tout compte bancaire. Incluez des champs privés pour accountNumber (String) et balance (double), un constructeur qui initialise les deux, les accesseurs appropriés, un accesseur modificateur protégé pour le solde (afin que les sous-classes puissent le modifier), ainsi qu’une méthode abstraite getAccountType() qui renvoie un String. Implémentez une méthode getDetails() qui renvoie "[accountNumber] ([accountType]): $[balance]", avec le solde formaté à 2 décimales.
SavingsAccount.java : Créez une classe qui étend Account et implémente Transactable. Ajoutez un champ privé pour interestRate (double). Le constructeur reçoit accountNumber, le solde initial et interestRate. Implémentez getAccountType() pour renvoyer "Savings". Pour deposit(), ajoutez le montant au solde et renvoyez true. Pour withdraw(), si le montant dépasse le solde, renvoyez false ; sinon, soustrayez le montant et renvoyez true. Ajoutez une méthode applyInterest() qui augmente le solde de balance * interestRate (le taux est stocké sous forme de fraction, donc 0.05 signifie 5 %).
CheckingAccount.java : Créez une classe qui étend Account et implémente Transactable. Ajoutez un champ privé pour overdraftLimit (double). Le constructeur reçoit accountNumber, le solde initial et overdraftLimit. Implémentez getAccountType() pour renvoyer "Checking". Pour deposit(), ajoutez le montant et renvoyez true. Pour withdraw(), autorisez le retrait si le montant est inférieur ou égal au solde plus overdraftLimit ; renvoyez false s’il dépasse cette limite.
Bank.java : Créez une classe qui gère les comptes à l’aide d’un ArrayList. Incluez les méthodes suivantes :
- addAccount(Account account) - ajoute un compte à la banque
- findAccount(String accountNumber) - renvoie le Account ou null s’il n’est pas trouvé
- transfer(String fromAccount, String toAccount, double amount) - transfère de l’argent entre les comptes et lève InsufficientFundsException si le compte source ne dispose pas de fonds suffisants. En cas de réussite, renvoie "Transferred $[amount] from [fromAccount] to [toAccount]"
- getTotalDeposits() - renvoie la somme des soldes de tous les comptes
Main.java : Construisez votre système bancaire ! Vous recevrez une chaîne de commandes séparées par des virgules :
- SAVINGS:accountNumber:balance:interestRate
- CHECKING:accountNumber:balance:overdraftLimit
- DEPOSIT:accountNumber:amount
- WITHDRAW:accountNumber:amount
- TRANSFER:fromAccount:toAccount:amount
- INTEREST:accountNumber
Traitez chaque commande et affichez :
- SAVINGS/CHECKING : Account created: [accountNumber]
- DEPOSIT : Deposited $[amount] to [accountNumber]
- WITHDRAW : Withdrew $[amount] from [accountNumber] en cas de réussite, ou Withdrawal failed: [accountNumber]
- TRANSFER : affichez le message de réussite ou Transfer failed: [exception message]
- INTEREST : Interest applied to [accountNumber]
Après toutes les commandes, affichez --- Bank Summary ---, suivi des détails de chaque compte (à l’aide de getDetails()), puis enfin Total deposits: $[total], formaté à 2 décimales.

Vous recevrez une entrée : la chaîne de commandes séparées par des virgules.

Par exemple, avec l’entrée 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, votre sortie serait :

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

Remarquez comment le compte courant autorise le retrait de 600 $, bien qu’il ne dispose que d’un solde de 500 $ : c’est la protection contre le découvert en action ! Le compte d’épargne rapporte 5 % d’intérêts sur son solde après le transfert. Ce défi combine l’héritage, les interfaces, le polymorphisme, les exceptions personnalisées et l’encapsulation dans une application bancaire réaliste !

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        
        // TODO: Créer une instance de Bank
        
        // TODO: Diviser input par des virgules pour obtenir les commandes individuelles
        
        // TODO: Traiter chaque commande :
        // - SAVINGS:accountNumber:balance:interestRate -> Create SavingsAccount, print "Account created: [accountNumber]"
        // - CHECKING:accountNumber:balance:overdraftLimit -> Create CheckingAccount, print "Account created: [accountNumber]"
        // - DEPOSIT:accountNumber:amount -> Déposer et afficher "Deposited $[amount] to [accountNumber]"
        // - WITHDRAW:accountNumber:amount -> Withdraw and print success or "Withdrawal failed: [accountNumber]"
        // - TRANSFER:fromAccount:toAccount:amount -> Transférer et afficher le succès ou "Transfer failed: [exception message]"
        // - INTEREST:accountNumber -> Apply interest and print "Interest applied to [accountNumber]"
        
        // TODO: Après toutes les commandes, afficher "--- Bank Summary ---"
        
        // TODO: Afficher les détails de chaque compte en utilisant getDetails()
        
        // TODO: Print "Total deposits: $[total]" formatted to 2 decimal places
    }
}