Menu
CoddyTech

Bankingsystem

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

Bei dieser Herausforderung entwickelst du ein Bankensystem, das reale Finanzgeschäfte mithilfe von OOP-Prinzipien modelliert.

Dein System sollte verschiedene Kontotypen wie SavingsAccount und CheckingAccount unterstützen, die beide von einer Basisklasse Account abgeleitet sind. Jeder Kontotyp hat einzigartige Verhaltensweisen: Sparkonten können Zinsen verdienen, während Girokonten einen Überziehungsschutz haben können.

Überlege, wie sich Transaktionen modellieren lassen. Ein Interface wie Transactable könnte Methoden für deposit() und withdraw() definieren. Ziehe benutzerdefinierte Ausnahmen wie InsufficientFundsException in Betracht, um ungültige Vorgänge elegant zu behandeln.

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

Konzentriere dich auf die Kapselung, um sensible Daten wie Kontostände und Kontonummern zu schützen, und nutze Polymorphismus, um verschiedene Kontotypen einheitlich zu verarbeiten.

challenge icon

Aufgabe

Einfach

Lass uns ein vollständiges Bankensystem entwickeln, das deine Beherrschung der OOP-Prinzipien unter Beweis stellt! Du erstellst ein System mit verschiedenen Kontotypen, Transaktionsverarbeitung und ordnungsgemäßer Ausnahmebehandlung, das auf mehrere Dateien verteilt ist.

Du verteilst deinen Code auf sieben Dateien:

  • 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 booleschen Wert zurückgeben, um den Erfolg anzuzeigen.
  • InsufficientFundsException.java: Erstelle eine benutzerdefinierte Ausnahme, die Exception erweitert. Der Konstruktor soll den versuchten Auszahlungsbetrag und den aktuellen Kontostand entgegennehmen und eine Meldung 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, passende Getter, einen geschützten Setter für den Kontostand (damit Unterklassen ihn ändern können) und 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 nimmt accountNumber, den anfänglichen Kontostand und interestRate entgegen. Implementiere getAccountType(), sodass die Methode "Savings" zurückgibt. Bei deposit() wird der Betrag zum Kontostand addiert und true zurückgegeben. Wenn bei withdraw() der Betrag den Kontostand übersteigt, wird false zurückgegeben; andernfalls wird der Betrag abgezogen und true zurückgegeben. Füge eine Methode applyInterest() hinzu, die den Kontostand um balance * interestRate erhöht (der Zinssatz wird als Bruchzahl 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 nimmt accountNumber, den anfänglichen Kontostand und overdraftLimit entgegen. Implementiere getAccountType(), sodass die Methode "Checking" zurückgibt. Bei deposit() wird der Betrag addiert und true zurückgegeben. Bei withdraw() ist eine Auszahlung zulässig, wenn der Betrag kleiner oder gleich dem Kontostand zuzüglich overdraftLimit ist; übersteigt er dieses Limit, wird false zurückgegeben.
  • Bank.java: Erstelle eine Klasse, die Konten mithilfe einer ArrayList verwaltet. Füge folgende Methoden hinzu:
    • addAccount(Account account) – fügt der Bank ein Konto hinzu
    • findAccount(String accountNumber) – gibt das Account zurück oder null, falls es nicht gefunden wurde
    • transfer(String fromAccount, String toAccount, double amount) – überweist Geld zwischen Konten und löst InsufficientFundsException aus, wenn das Quellkonto nicht ausreichend gedeckt ist. Bei Erfolg wird "Transferred $[amount] from [fromAccount] to [toAccount]" zurückgegeben
    • getTotalDeposits() – gibt die Summe aller Kontostände zurück
  • Main.java: Baue 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], andernfalls 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] mit 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äre deine Ausgabe zum Beispiel:

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, dass das Girokonto die Auszahlung von $600 zulässt, obwohl es nur einen Kontostand von $500 hat: Das ist der Überziehungsschutz in Aktion! Das Sparkonto erhält nach der Überweisung 5 % Zinsen auf seinen Kontostand. Bei dieser Herausforderung kommen Vererbung, Interfaces, Polymorphie, benutzerdefinierte Ausnahmen und Kapselung in einer realistischen Bankanwendung zusammen!

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: Eine Bank-Instanz erstellen
        
        // TODO: input an Kommas aufteilen, um die einzelnen Befehle zu erhalten
        
        // TODO: Jeden Befehl verarbeiten:
        // - SAVINGS:accountNumber:balance:interestRate -> SavingsAccount erstellen und "Account created: [accountNumber]" ausgeben
        // - CHECKING:accountNumber:balance:overdraftLimit -> CheckingAccount erstellen und "Account created: [accountNumber]" ausgeben
        // - DEPOSIT:accountNumber:amount -> Betrag einzahlen und "Deposited $[amount] to [accountNumber]" ausgeben
        // - WITHDRAW:accountNumber:amount -> Betrag abheben und bei Erfolg eine Erfolgsmeldung, andernfalls "Withdrawal failed: [accountNumber]" ausgeben
        // - TRANSFER:fromAccount:toAccount:amount -> Betrag überweisen und bei Erfolg eine Erfolgsmeldung, andernfalls "Transfer failed: [exception message]" ausgeben
        // - INTEREST:accountNumber -> Zinsen gutschreiben und "Interest applied to [accountNumber]" ausgeben
        
        // TODO: Nach allen Befehlen "--- Bank Summary ---" ausgeben
        
        // TODO: Die Details jedes Kontos mit getDetails() ausgeben
        
        // TODO: "Total deposits: $[total]" mit 2 Nachkommastellen formatiert ausgeben
    }
}
quiz iconTeste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Alle Lektionen in Objektorientierte Programmierung

Übe selbstständig: Online-Java-Compiler