Banking Application in Java

A basic banking application can simulate common banking operations like creating accounts, depositing and withdrawing money, checking balances, and transferring money between accounts. Here, I’ll provide a simple Java implementation of such an application, with a basic menu-based user interface. This application will focus on essential features such as:

1. Account creation
2. Deposits
3. Withdrawals
4. Balance checking
5. Money transfer

We’ll implement this using object-oriented principles, with the following classes:

• BankAccount: Represents a bank account and handles operations such as deposit, withdrawal, balance checking, and transferring money.
• BankingApp: A class with a main() method to provide an interactive menu and manage user input.

Step-by-step Implementation:

1. Create a BankAccount Class

This class will define the account details, including the account holder’s name, account number, balance, and operations like deposit, withdrawal, and balance checking.

public class BankAccount {
    private String accountHolder;
    private String accountNumber;
    private double balance;

    // Constructor to initialize a bank account
    public BankAccount(String accountHolder, String accountNumber, double initialBalance) {
        this.accountHolder = accountHolder;
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }

    // Deposit method
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("Deposited: " + amount);
        } else {
            System.out.println("Deposit amount must be positive.");
        }
    }

    // Withdrawal method
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("Withdrew: " + amount);
        } else if (amount > balance) {
            System.out.println("Insufficient funds.");
        } else {
            System.out.println("Withdrawal amount must be positive.");
        }
    }

    // Transfer method
    public void transfer(BankAccount recipient, double amount) {
        if (amount > 0 && amount <= balance) {
            this.withdraw(amount);
            recipient.deposit(amount);
            System.out.println("Transferred: " + amount + " to " + recipient.getAccountHolder());
        } else {
            System.out.println("Transfer failed. Insufficient funds or invalid amount.");
        }
    }

    // Check balance
    public double checkBalance() {
        return balance;
    }

    // Getters
    public String getAccountHolder() {
        return accountHolder;
    }

    public String getAccountNumber() {
        return accountNumber;
    }
}

2. Create the BankingApp Class

This class will include the main method that provides a menu for the user to interact with the bank accounts.

import java.util.Scanner;

public class BankingApp {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Sample accounts
        BankAccount account1 = new BankAccount("Alice", "12345", 1000.0);
        BankAccount account2 = new BankAccount("Bob", "67890", 500.0);

        while (true) {
            // Display menu
            System.out.println("\nWelcome to the Banking Application!");
            System.out.println("1. Check Balance");
            System.out.println("2. Deposit");
            System.out.println("3. Withdraw");
            System.out.println("4. Transfer Money");
            System.out.println("5. Exit");
            System.out.print("Enter your choice: ");

            int choice = scanner.nextInt();

            switch (choice) {
                case 1: // Check Balance
                    System.out.println("Balance for Alice: " + account1.checkBalance());
                    System.out.println("Balance for Bob: " + account2.checkBalance());
                    break;

                case 2: // Deposit
                    System.out.print("Enter amount to deposit: ");
                    double depositAmount = scanner.nextDouble();
                    account1.deposit(depositAmount);
                    break;

                case 3: // Withdraw
                    System.out.print("Enter amount to withdraw: ");
                    double withdrawAmount = scanner.nextDouble();
                    account1.withdraw(withdrawAmount);
                    break;

                case 4: // Transfer Money
                    System.out.print("Enter amount to transfer: ");
                    double transferAmount = scanner.nextDouble();
                    account1.transfer(account2, transferAmount);
                    break;

                case 5: // Exit
                    System.out.println("Thank you for using the Banking Application. Goodbye!");
                    scanner.close();
                    return;

                default:
                    System.out.println("Invalid choice. Please try again.");
            }
        }
    }
}

Explanation of the Code:

1. BankAccount Class:
   • Instance Variables:
     • accountHolder: The name of the account holder.
     • accountNumber: Unique identifier for the account.
     • balance: The current balance in the account.
   • Constructor: Initializes the account with the holder’s name, account number, and an initial balance.
   • Methods:
     • deposit(): Adds the specified amount to the account balance.
     • withdraw(): Subtracts the specified amount from the account balance if sufficient funds are available.
     • transfer(): Transfers money between two BankAccount objects.
     • checkBalance(): Returns the current balance of the account.
2. BankingApp Class:
   • Scanner: Used to read input from the user.
   • Menu: Provides a simple text-based interface with five options:
     1. Check Balance: Displays the current balance of both accounts.
     2. Deposit: Allows the user to deposit money into account1 (Alice’s account).
     3. Withdraw: Allows the user to withdraw money from account1.
     4. Transfer Money: Allows the user to transfer money from account1 (Alice) to account2 (Bob).
     5. Exit: Exits the application.
3. Sample Account: Two BankAccount objects (account1 and account2) are created with initial balances for testing purposes.

Example Execution:

Welcome to the Banking Application!
1. Check Balance
2. Deposit
3. Withdraw
4. Transfer Money
5. Exit
Enter your choice: 1
Balance for Alice: 1000.0
Balance for Bob: 500.0

Welcome to the Banking Application!
1. Check Balance
2. Deposit
3. Withdraw
4. Transfer Money
5. Exit
Enter your choice: 2
Enter amount to deposit: 200
Deposited: 200.0

Welcome to the Banking Application!
1. Check Balance
2. Deposit
3. Withdraw
4. Transfer Money
5. Exit
Enter your choice: 3
Enter amount to withdraw: 150
Withdrew: 150.0

Welcome to the Banking Application!
1. Check Balance
2. Deposit
3. Withdraw
4. Transfer Money
5. Exit
Enter your choice: 4
Enter amount to transfer: 100
Transferred: 100.0 to Bob

Welcome to the Banking Application!
1. Check Balance
2. Deposit
3. Withdraw
4. Transfer Money
5. Exit
Enter your choice: 5
Thank you for using the Banking Application. Goodbye!

Key Features:

• Deposit: Users can deposit money into an account.
• Withdraw: Users can withdraw money from an account.
• Transfer: Money can be transferred between two accounts.
• Balance Check: Users can check their account balance.

Improvements You Can Make:

1. Multiple Accounts: Support for multiple users with different account numbers and balances.
2. Interest Calculation: Add features like interest calculation for savings accounts.
3. Account Types: Implement different types of accounts (e.g., checking, savings).
4. File I/O: Store account information in a file and load it at application startup.
5. User Authentication: Implement username and password-based login for security.

This simple Java-based banking application can be expanded in many ways to handle more complex banking functionalities.