Bankingsystem

Teil des Abschnitts Objektorientierte Programmierung der Java-Journey von Coddy. Lektion 85 von 87.

Diese Herausforderung besteht darin, ein Banksystem zu entwickeln, das reale Finanzgeschäfte mithilfe von OOP-Prinzipien modelliert.

Dein System sollte verschiedene Kontotypen wie SavingsAccount und CheckingAccount verarbeiten, die beide eine Basisklasse Account erweitern. Jeder Kontotyp weist ein einzigartiges Verhalten auf: Sparkonten können Zinsen erwirtschaften, während Girokonten einen Überziehungsschutz bieten könnten.

Überlege, wie Transaktionen modelliert werden können. Ein Interface wie Transactable könnte Methoden für deposit() und withdraw() definieren. Erwäge die Verwendung benutzerdefinierter Ausnahmen wie InsufficientFundsException, um ungültige Vorgänge angemessen zu behandeln.

Eine Bank-Klasse könnte mehrere Konten und Kunden verwalten und dadurch Komposition demonstrieren. Du könntest das Factory-Muster anwenden, um verschiedene Kontotypen zu erstellen, oder das Observer-Muster verwenden, um Kunden über Kontoänderungen zu benachrichtigen.

Konzentriere dich auf die Kapselung, um sensible Daten wie Guthaben und Kontonummern zu schützen, und verwende Polymorphie, um verschiedene Kontotypen einheitlich zu verarbeiten.

Aufgabe

Einfach

Lass uns ein vollständiges Bankensystem erstellen, das deine Beherrschung der OOP-Prinzipien demonstriert! Du wirst ein System mit verschiedenen Kontotypen, Transaktionsverarbeitung und ordnungsgemäßem Ausnahme-Management erstellen, das über mehrere Dateien organisiert ist.

Du wirst deinen Code auf sieben Dateien verteilen:

Transactable.java: Erstelle ein Interface, das den Vertrag für Finanzoperationen definiert. Es soll die Methoden deposit(double amount) und withdraw(double amount) deklarieren, die beide einen Boolean zurückgeben, um den Erfolg anzuzeigen.
InsufficientFundsException.java: Erstelle eine benutzerdefinierte Exception, die Exception erweitert. Der Konstruktor soll den versuchten Abhebungsbetrag und den aktuellen Kontostand akzeptieren und eine Nachricht im Format Insufficient funds: attempted [amount], available [balance] erstellen.
Account.java: Erstelle eine abstrakte Basisklasse, die ein beliebiges Bankkonto repräsentiert. Füge private Felder für accountNumber (String) und balance (double), einen Konstruktor, der beide initialisiert, geeignete Getter, einen geschützten Setter für den Kontostand (damit Unterklassen ihn ändern können) sowie eine abstrakte Methode getAccountType() hinzu, die einen String zurückgibt. Implementiere eine Methode getDetails(), die "[accountNumber] ([accountType]): $[balance]" mit einem auf 2 Dezimalstellen formatierten Kontostand zurückgibt.
SavingsAccount.java: Erstelle eine Klasse, die Account erweitert und Transactable implementiert. Füge ein privates Feld für interestRate (double) hinzu. Der Konstruktor erhält accountNumber, den anfänglichen Kontostand und interestRate. Implementiere getAccountType(), sodass "Savings" zurückgegeben wird. Bei deposit() soll der Betrag zum Kontostand addiert und true zurückgegeben werden. Wenn der Betrag bei withdraw() den Kontostand überschreitet, soll false zurückgegeben werden; andernfalls soll der Betrag abgezogen und true zurückgegeben werden. Füge eine Methode applyInterest() hinzu, die den Kontostand um balance * interestRate erhöht (der Zinssatz wird als Bruch gespeichert, daher bedeutet 0.05 5%).
CheckingAccount.java: Erstelle eine Klasse, die Account erweitert und Transactable implementiert. Füge ein privates Feld für overdraftLimit (double) hinzu. Der Konstruktor erhält accountNumber, den anfänglichen Kontostand und overdraftLimit. Implementiere getAccountType(), sodass "Checking" zurückgegeben wird. Bei deposit() soll der Betrag addiert und true zurückgegeben werden. Bei withdraw() soll die Abhebung erlaubt werden, wenn der Betrag kleiner oder gleich dem Kontostand plus overdraftLimit ist; andernfalls soll false zurückgegeben werden.
Bank.java: Erstelle eine Klasse, die Konten mithilfe einer ArrayList verwaltet. Füge folgende Methoden hinzu:
- addAccount(Account account) – fügt ein Konto zur Bank hinzu
- findAccount(String accountNumber) – gibt das Account zurück oder null, wenn es nicht gefunden wurde
- transfer(String fromAccount, String toAccount, double amount) – überweist Geld zwischen Konten und löst InsufficientFundsException aus, wenn das Quellkonto nicht über ausreichende Mittel verfügt. Bei Erfolg soll "Transferred $[amount] from [fromAccount] to [toAccount]" zurückgegeben werden
- getTotalDeposits() – gibt die Summe aller Kontostände zurück
Main.java: Erstelle dein Bankensystem! Du erhältst eine durch Kommas getrennte Zeichenfolge mit Befehlen:
- SAVINGS:accountNumber:balance:interestRate
- CHECKING:accountNumber:balance:overdraftLimit
- DEPOSIT:accountNumber:amount
- WITHDRAW:accountNumber:amount
- TRANSFER:fromAccount:toAccount:amount
- INTEREST:accountNumber
Verarbeite jeden Befehl und gib Folgendes aus:
- SAVINGS/CHECKING: Account created: [accountNumber]
- DEPOSIT: Deposited $[amount] to [accountNumber]
- WITHDRAW: Bei Erfolg Withdrew $[amount] from [accountNumber] oder Withdrawal failed: [accountNumber]
- TRANSFER: Gib die Erfolgsmeldung oder Transfer failed: [exception message] aus
- INTEREST: Interest applied to [accountNumber]
Gib nach allen Befehlen --- Bank Summary ---, anschließend die Details jedes Kontos (mithilfe von getDetails()) und schließlich Total deposits: $[total], formatiert auf 2 Dezimalstellen, aus.

Du erhältst eine Eingabe: die durch Kommas getrennte Befehlszeichenfolge.

Bei der Eingabe 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 würde deine Ausgabe beispielsweise folgendermaßen aussehen:

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

Beachte, wie das Girokonto die Abhebung von $600 trotz eines Kontostands von nur $500 erlaubt: Das ist der Überziehungsschutz in Aktion! Das Sparkonto erhält nach der Überweisung 5 % Zinsen auf seinen Kontostand. Diese Herausforderung verbindet Vererbung, Interfaces, Polymorphie, benutzerdefinierte Exceptions und Kapselung zu einer realistischen Bankanwendung!

Probier es selbst

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        
        // TODO: Erstelle eine Bank-Instanz
        
        // TODO: Teile input am Komma auf, um einzelne Befehle zu erhalten
        
        // TODO: Verarbeite jeden Befehl:
        // - SAVINGS:accountNumber:balance:interestRate -> Create SavingsAccount, print "Account created: [accountNumber]"
        // - CHECKING:accountNumber:balance:overdraftLimit -> Create CheckingAccount, print "Account created: [accountNumber]"
        // - DEPOSIT:accountNumber:amount -> Einzahlen und "Deposited $[amount] to [accountNumber]" ausgeben
        // - WITHDRAW:accountNumber:amount -> Withdraw and print success or "Withdrawal failed: [accountNumber]"
        // - TRANSFER:fromAccount:toAccount:amount -> Überweisen und Erfolg ausgeben oder "Transfer failed: [exception message]"
        // - INTEREST:accountNumber -> Apply interest and print "Interest applied to [accountNumber]"
        
        // TODO: Nach allen Befehlen "--- Bank Summary ---" ausgeben
        
        // TODO: Gib die Details jedes Kontos mit getDetails() aus
        
        // TODO: Print "Total deposits: $[total]" formatted to 2 decimal places
    }
}