Sistema Bancário

Parte da seção Programação Orientada a Objetos do Journey de Java da Coddy. Lição 85 de 87.

Este desafio pede que você construa um Sistema Bancário que modele operações financeiras do mundo real usando princípios de POO.

Seu sistema deve lidar com diferentes tipos de conta, como SavingsAccount e CheckingAccount, ambos estendendo uma classe base Account. Cada tipo de conta tem comportamentos exclusivos: contas de poupança podem render juros, enquanto contas correntes podem ter proteção contra descoberto.

Pense em como modelar transações. Uma interface como Transactable poderia definir métodos para deposit() e withdraw(). Considere usar exceções personalizadas, como InsufficientFundsException, para lidar com operações inválidas de maneira adequada.

Uma classe Bank pode gerenciar várias contas e clientes, demonstrando composição. Você poderia aplicar o padrão Factory para criar diferentes tipos de conta ou usar o padrão Observer para notificar os clientes sobre alterações nas contas.

Concentre-se no encapsulamento para proteger dados confidenciais, como balances e accountNumber, e use polimorfismo para processar diferentes tipos de conta de maneira uniforme.

Desafio

Fácil

Vamos criar um Sistema Bancário completo que demonstra seu domínio dos princípios de POO! Você criará um sistema com diferentes tipos de conta, processamento de transações e gerenciamento adequado de exceções: tudo organizado em vários arquivos.

Você organizará seu código em sete arquivos:

Transactable.java: Crie uma interface que defina o contrato para operações financeiras. Ela deve declarar os métodos deposit(double amount) e withdraw(double amount), ambos retornando um booleano para indicar sucesso.
InsufficientFundsException.java: Crie uma exceção personalizada que estenda Exception. O construtor deve aceitar o valor da retirada tentada e o saldo atual, criando uma mensagem no formato Insufficient funds: attempted [amount], available [balance].
Account.java: Crie uma classe base abstrata que represente qualquer conta bancária. Inclua campos privados para accountNumber (String) e balance (double), um construtor que inicialize ambos, getters apropriados, um setter protegido para o saldo (para que as subclasses possam modificá-lo) e um método abstrato getAccountType() que retorne uma String. Implemente um método getDetails() que retorne "[accountNumber] ([accountType]): $[balance]", com o saldo formatado para 2 casas decimais.
SavingsAccount.java: Crie uma classe que estenda Account e implemente Transactable. Adicione um campo privado para interestRate (double). O construtor recebe accountNumber, saldo inicial e interestRate. Implemente getAccountType() para retornar "Savings". Para deposit(), adicione o valor ao saldo e retorne true. Para withdraw(), se o valor exceder o saldo, retorne false; caso contrário, subtraia o valor e retorne true. Adicione um método applyInterest() que aumente o saldo em balance * interestRate (a taxa é armazenada como uma fração, portanto 0.05 significa 5%).
CheckingAccount.java: Crie uma classe que estenda Account e implemente Transactable. Adicione um campo privado para overdraftLimit (double). O construtor recebe accountNumber, saldo inicial e overdraftLimit. Implemente getAccountType() para retornar "Checking". Para deposit(), adicione o valor e retorne true. Para withdraw(), permita a retirada se o valor for menor ou igual ao saldo mais overdraftLimit; retorne false se ele exceder esse limite.
Bank.java: Crie uma classe que gerencie contas usando um ArrayList. Inclua os métodos:
- addAccount(Account account) - adiciona uma conta ao banco
- findAccount(String accountNumber) - retorna a Account ou null se não for encontrada
- transfer(String fromAccount, String toAccount, double amount) - transfere dinheiro entre contas, lançando InsufficientFundsException se a conta de origem não tiver fundos suficientes. Em caso de sucesso, retorne "Transferred $[amount] from [fromAccount] to [toAccount]"
- getTotalDeposits() - retorna a soma de todos os saldos das contas
Main.java: Crie seu sistema bancário! Você receberá uma string de comandos separados por vírgulas:
- SAVINGS:accountNumber:balance:interestRate
- CHECKING:accountNumber:balance:overdraftLimit
- DEPOSIT:accountNumber:amount
- WITHDRAW:accountNumber:amount
- TRANSFER:fromAccount:toAccount:amount
- INTEREST:accountNumber
Processe cada comando e imprima:
- SAVINGS/CHECKING: Account created: [accountNumber]
- DEPOSIT: Deposited $[amount] to [accountNumber]
- WITHDRAW: Withdrew $[amount] from [accountNumber] em caso de sucesso, ou Withdrawal failed: [accountNumber]
- TRANSFER: Imprima a mensagem de sucesso ou Transfer failed: [exception message]
- INTEREST: Interest applied to [accountNumber]
Após todos os comandos, imprima --- Bank Summary ---, seguido pelos detalhes de cada conta (usando getDetails()) e, por fim, Total deposits: $[total] formatado para 2 casas decimais.

Você receberá uma entrada: a string de comandos separados por vírgulas.

Por exemplo, com a entrada 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, sua saída seria:

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

Observe como a conta corrente permite a retirada de $600 apesar de ter apenas $500 de saldo: essa é a proteção contra descoberto em ação! A conta poupança rende 5% de juros sobre seu saldo após a transferência. Este desafio combina herança, interfaces, polimorfismo, exceções personalizadas e encapsulamento em uma aplicação bancária realista!

Experimente você mesmo

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        
        // TODO: Crie uma instância de Bank
        
        // TODO: Divida a entrada por vírgula para obter os comandos individuais
        
        // TODO: Processe cada comando:
        // - SAVINGS:accountNumber:balance:interestRate -> Create SavingsAccount, print "Account created: [accountNumber]"
        // - CHECKING:accountNumber:balance:overdraftLimit -> Create CheckingAccount, print "Account created: [accountNumber]"
        // - DEPOSIT:accountNumber:amount -> Deposite e imprima "Deposited $[amount] to [accountNumber]"
        // - WITHDRAW:accountNumber:amount -> Withdraw and print success or "Withdrawal failed: [accountNumber]"
        // - TRANSFER:fromAccount:toAccount:amount -> Transfira e imprima sucesso ou "Transfer failed: [exception message]"
        // - INTEREST:accountNumber -> Apply interest and print "Interest applied to [accountNumber]"
        
        // TODO: Após todos os comandos, imprima "--- Bank Summary ---"
        
        // TODO: Imprima os detalhes de cada conta usando getDetails()
        
        // TODO: Print "Total deposits: $[total]" formatted to 2 decimal places
    }
}