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 construire un système bancaire qui modélise des opérations financières réelles en utilisant les principes de la POO.

Votre système doit gérer différents types de comptes tels que SavingsAccount et CheckingAccount, tous deux étendant une classe Account de base. Chaque type de compte a des comportements uniques : les comptes d'épargne pourraient générer des intérêts, tandis que les comptes chèques pourraient avoir 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 pourrait gérer plusieurs comptes et clients, démontrant ainsi la composition. Vous pourriez appliquer le pattern Factory pour créer différents types de comptes, ou utiliser le pattern Observer pour informer les clients des changements de compte.

Concentrez-vous sur l'encapsulation pour protéger les données sensibles telles que 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 allez créer 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), toutes deux retournant un booléen pour indiquer la réussite.
InsufficientFundsException.java : Créez une exception personnalisée qui étend Exception. Le constructeur doit accepter le montant de retrait tenté et le solde actuel, en créant un message au format "Insufficient funds: attempted %.2f, available %.2f".
Account.java : Créez une classe de base abstraite représentant n'importe quel compte bancaire. Incluez des champs privés pour accountNumber (String) et balance (double), un constructeur qui initialise les deux, des getters appropriés, un setter protégé pour le solde (afin que les sous-classes puissent le modifier), et une méthode abstraite getAccountType() qui retourne une String. Implémentez une méthode getDetails() qui retourne "%s (%s): $%.2f" 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 prend accountNumber, le solde initial et interestRate. Implémentez getAccountType() pour retourner "Savings". Pour deposit(), ajoutez le montant au solde et retournez true. Pour withdraw(), si le montant dépasse le solde, retournez false ; sinon, soustrayez et retournez true. Ajoutez une méthode applyInterest() qui augmente le solde du pourcentage du taux d'intérêt.
CheckingAccount.java : Créez une classe qui étend Account et implémente Transactable. Ajoutez un champ privé pour overdraftLimit (double). Le constructeur prend accountNumber, le solde initial et overdraftLimit. Implémentez getAccountType() pour retourner "Checking". Pour deposit(), ajoutez le montant et retournez true. Pour withdraw(), autorisez le retrait si le montant est inférieur ou égal au solde plus overdraftLimit ; retournez false s'il dépasse cette limite.
Bank.java : Créez une classe qui gère les comptes à l'aide d'une ArrayList. Incluez les méthodes :
- addAccount(Account account) - ajoute un compte à la banque
- findAccount(String accountNumber) - retourne le compte ou null s'il n'est pas trouvé
- transfer(String fromAccount, String toAccount, double amount) - transfère de l'argent entre les comptes, en lançant InsufficientFundsException si le compte source a des fonds insuffisants. En cas de succès, retournez "Transferred $%.2f from %s to %s"
- getTotalDeposits() - retourne la somme de tous les soldes des 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: " suivi de accountNumber
- DEPOSIT : "Deposited $%.2f to %s%n"
- WITHDRAW : "Withdrew $%.2f from %s%n" en cas de succès, ou "Withdrawal failed: " suivi de accountNumber
- TRANSFER : Affichez le message de succès ou "Transfer failed: " suivi du message de l'exception
- INTEREST : "Interest applied to " suivi de accountNumber
Après toutes les commandes, affichez "--- Bank Summary ---" suivi des détails de chaque compte (en utilisant getDetails()) et enfin "Total deposits: $%.2f%n" formaté à 2 décimales.

Vous recevrez une seule 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 chèque permet le retrait de 600 $ malgré un solde de seulement 500 $—c'est la protection contre les découverts en action ! Le compte d'épargne gagne 5 % d'intérêt 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 !

Aide-mémoire

Un Système Bancaire démontre les principes de la POO à travers la gestion de comptes, les transactions et la gestion des exceptions.

Interfaces pour les Contrats

Définissez les opérations communes à l'aide d'interfaces :

public interface Transactable {
    boolean deposit(double amount);
    boolean withdraw(double amount);
}

Exceptions Personnalisées

Créez des exceptions personnalisées pour les erreurs spécifiques au domaine :

public class InsufficientFundsException extends Exception {
    public InsufficientFundsException(double attempted, double available) {
        super("Insufficient funds: attempted " + attempted + ", available " + available);
    }
}

Classes de Base Abstraites

Utilisez des classes abstraites pour définir une structure commune avec des méthodes abstraites pour le comportement spécifique aux sous-classes :

public abstract class Account {
    private String accountNumber;
    private double balance;
    
    public abstract String getAccountType();
    
    protected void setBalance(double balance) {
        this.balance = balance;
    }
}

Héritage et Polymorphisme

Les sous-classes étendent les classes de base et implémentent les interfaces :

public class SavingsAccount extends Account implements Transactable {
    private double interestRate;
    
    @Override
    public String getAccountType() {
        return "Savings";
    }
    
    public void applyInterest() {
        setBalance(getBalance() * (1 + interestRate));
    }
}

Composition

Les classes peuvent gérer des collections d'autres objets :

public class Bank {
    private ArrayList<Account> accounts;
    
    public void addAccount(Account account) {
        accounts.add(account);
    }
    
    public Account findAccount(String accountNumber) {
        // Search and return account or null
    }
}

Encapsulation

Protégez les données sensibles avec des champs privés et un accès contrôlé via des getters/setters. Utilisez les modificateurs protected pour permettre l'accès aux sous-classes tout en maintenant l'encapsulation.

Gestion des Exceptions dans les Transactions

Levez des exceptions personnalisées pour les opérations invalides :

public String transfer(String from, String to, double amount) throws InsufficientFundsException {
    if (!fromAccount.withdraw(amount)) {
        throw new InsufficientFundsException(amount, fromAccount.getBalance());
    }
    toAccount.deposit(amount);
    return "Transferred $" + amount;
}

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 l'entrée par virgule pour obtenir les commandes individuelles
        
        // TODO: Traiter chaque commande :
        // - SAVINGS:accountNumber:balance:interestRate -> Créer un SavingsAccount, afficher "Account created: [accountNumber]"
        // - CHECKING:accountNumber:balance:overdraftLimit -> Créer un CheckingAccount, afficher "Account created: [accountNumber]"
        // - DEPOSIT:accountNumber:amount -> Déposer et afficher "Deposited $[amount] to [accountNumber]"
        // - WITHDRAW:accountNumber:amount -> Retirer et afficher le succès ou "Withdrawal failed: [accountNumber]"
        // - TRANSFER:fromAccount:toAccount:amount -> Transférer et afficher le succès ou "Transfer failed: [exception message]"
        // - INTEREST:accountNumber -> Appliquer les intérêts et afficher "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: Afficher "Total deposits: $[total]" formaté à 2 décimales
    }
}