Menu
CoddyTech

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 propõe que você crie 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 únicos: contas poupança podem render juros, enquanto contas correntes podem ter proteção contra saldo negativo.

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 tratar operações inválidas de forma 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 saldos e números de conta, e use o polimorfismo para processar diferentes tipos de conta de maneira uniforme.

challenge icon

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, tratamento 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 define 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 estende Exception. O construtor deve aceitar o valor da tentativa de saque 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 retorna uma String. Implemente um método getDetails() que retorna "[accountNumber] ([accountType]): $[balance]", com o saldo formatado com 2 casas decimais.
  • SavingsAccount.java: Crie uma classe que estende Account e implementa Transactable. Adicione um campo privado para interestRate (double). O construtor recebe accountNumber, saldo inicial e interestRate. Implemente getAccountType() para retornar "Savings". Para deposit(), some 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 aumenta o saldo em balance * interestRate (a taxa é armazenada como uma fração, então 0.05 significa 5%).
  • CheckingAccount.java: Crie uma classe que estende Account e implementa Transactable. Adicione um campo privado para overdraftLimit (double). O construtor recebe accountNumber, saldo inicial e overdraftLimit. Implemente getAccountType() para retornar "Checking". Para deposit(), some o valor e retorne true. Para withdraw(), permita o saque se o valor for menor ou igual ao saldo mais overdraftLimit; retorne false se exceder esse limite.
  • Bank.java: Crie uma classe que gerencia 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, retorna "Transferred $[amount] from [fromAccount] to [toAccount]"
    • getTotalDeposits() - retorna a soma dos saldos de todas as contas
  • Main.java: Construa 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 dos detalhes de cada conta (usando getDetails()) e, por fim, Total deposits: $[total] formatado com 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 o saque de $600, apesar de ter apenas $500 de saldo: essa é a proteção contra saldo negativo em ação! A conta poupança rende 5% de juros sobre o saldo após a transferência. Este desafio combina herança, interfaces, polimorfismo, exceções personalizadas e encapsulamento em um aplicativo bancário 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: Separe input por vírgulas para obter os comandos individuais
        
        // TODO: Processe cada comando:
        // - SAVINGS:accountNumber:balance:interestRate -> Crie SavingsAccount e imprima "Account created: [accountNumber]"
        // - CHECKING:accountNumber:balance:overdraftLimit -> Crie CheckingAccount e imprima "Account created: [accountNumber]"
        // - DEPOSIT:accountNumber:amount -> Faça o depósito e imprima "Deposited $[amount] to [accountNumber]"
        // - WITHDRAW:accountNumber:amount -> Faça o saque e imprima a confirmação de sucesso ou "Withdrawal failed: [accountNumber]"
        // - TRANSFER:fromAccount:toAccount:amount -> Faça a transferência e imprima a confirmação de sucesso ou "Transfer failed: [exception message]"
        // - INTEREST:accountNumber -> Aplique os juros e imprima "Interest applied to [accountNumber]"
        
        // TODO: Após todos os comandos, imprima "--- Bank Summary ---"
        
        // TODO: Imprima os detalhes de cada conta usando getDetails()
        
        // TODO: Imprima "Total deposits: $[total]" formatado com 2 casas decimais
    }
}
quiz iconTeste seus conhecimentos

Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.

Todas as lições de Programação Orientada a Objetos

Pratique por conta própria: Compilador de Java online