Banking System

The Banking System is a simple yet effective Java application designed to simulate the core functionalities of a real-world banking interface. This project introduces the concepts of user authentication, data validation, and transaction management through object-oriented programming. It allows users to register with a username and password, log into their account, check their balance, deposit funds, withdraw amounts with sufficient balance checks, and view transaction history. The console-based interface provides a menu-driven structure for user interactions. This application not only strengthens Java OOP concepts but also mirrors the structure of real banking systems, making it a practical project for students and interns.

The Banking System in Java is a console-based application designed to simulate fundamental banking operations such as account creation, login authentication, balance checking, deposits, withdrawals, and viewing transaction history. This project serves as an excellent way to apply Object-Oriented Programming (OOP) principles and enhances the developer’s ability to handle real-world scenarios using Java.

🔧 Key Features:

  • User Registration & Login: Users can register by providing a unique username and password. Secure login ensures that only registered users can access their accounts.

  • Account Operations:

    • Check Balance: Displays the current balance of the user’s account.

    • Deposit Money: Allows users to deposit a specified amount into their account.

    • Withdraw Money: Enables withdrawal with a check to ensure sufficient balance is available.

  • Transaction History: Keeps a log of all deposits and withdrawals for each user session, enhancing transparency and traceability.

📚 Technical Concepts Used:

  • Classes and Objects: Each user is represented as an object with encapsulated fields and methods.

  • Encapsulation: Fields like balance and password are kept private, accessible only through public methods.

  • ArrayLists or HashMaps: Used to store and manage multiple user accounts dynamically.

  • Scanner Class: For taking user input in the console.

  • Conditional Logic: Ensures correct flow for transaction rules and validations.

💡 Learning Outcomes:

By building this project, the learner gains practical experience in:

  • Designing interactive, menu-driven Java applications.

  • Managing user authentication securely.

  • Implementing simple business logic with proper data validation.

  • Creating a basic, yet functional, financial application interface.

🔄 Future Scope:

The current version is in-memory and resets after each run. Future upgrades could include:

  • Persistent storage using files or databases (e.g., MySQL).

  • GUI version using Java Swing or JavaFX.

  • Multi-user system with authentication tokens or sessions.

  • Advanced features like fund transfers, mini-statements, and interest calculations.

✅ Conclusion:

This project mimics the behavior of a real-world banking interface, helping learners grasp both technical concepts and application design patterns used in enterprise-level systems. It provides a solid foundation for more complex financial software development using Java.

BankingSystem.java

import java.util.*;

class User {
    private String username;
    private String password;
    private double balance;
    private List<String> transactionHistory;

    public User(String username, String password) {
        this.username = username;
        this.password = password;
        this.balance = 0.0;
        this.transactionHistory = new ArrayList<>();
    }

    public String getUsername() { return username; }
    public boolean checkPassword(String pass) { return password.equals(pass); }

    public double getBalance() { return balance; }

    public void deposit(double amount) {
        balance += amount;
        transactionHistory.add(“Deposited ₹” + amount);
    }

    public boolean withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
            transactionHistory.add(“Withdrew ₹” + amount);
            return true;
        }
        return false;
    }

    public void showTransactionHistory() {
        if (transactionHistory.isEmpty()) {
            System.out.println(“📭 No transactions yet.”);
        } else {
            System.out.println(“\n📜 Transaction History:”);
            for (String t : transactionHistory) {
                System.out.println(” – ” + t);
            }
        }
    }
}

public class BankingSystem {
    private static Scanner sc = new Scanner(System.in);
    private static Map<String, User> users = new HashMap<>();
    private static User currentUser = null;

    public static void main(String[] args) {
        int choice;
        do {
            System.out.println(“\n🏦 Welcome to Simple Bank”);
            System.out.println(“1. Register”);
            System.out.println(“2. Login”);
            System.out.println(“0. Exit”);
            System.out.print(“Enter choice: “);
            choice = sc.nextInt();

            switch (choice) {
                case 1 -> register();
                case 2 -> login();
                case 0 -> System.out.println(“👋 Goodbye!”);
                default -> System.out.println(“❌ Invalid option.”);
            }
        } while (choice != 0);
    }

    private static void register() {
        sc.nextLine(); // consume newline
        System.out.print(“Choose username: “);
        String username = sc.nextLine();

        if (users.containsKey(username)) {
            System.out.println(“❌ Username already exists. Try another.”);
            return;
        }

        System.out.print(“Choose password: “);
        String password = sc.nextLine();

        users.put(username, new User(username, password));
        System.out.println(“✅ Registered successfully!”);
    }

    private static void login() {
        sc.nextLine();
        System.out.print(“Enter username: “);
        String username = sc.nextLine();

        if (!users.containsKey(username)) {
            System.out.println(“❌ No such user. Please register first.”);
            return;
        }

        System.out.print(“Enter password: “);
        String password = sc.nextLine();

        User user = users.get(username);
        if (user.checkPassword(password)) {
            currentUser = user;
            System.out.println(“✅ Login successful!”);
            accountMenu();
        } else {
            System.out.println(“❌ Incorrect password.”);
        }
    }

    private static void accountMenu() {
        int choice;
        do {
            System.out.println(“\n🔐 Account Menu for ” + currentUser.getUsername());
            System.out.println(“1. Check Balance”);
            System.out.println(“2. Deposit Money”);
            System.out.println(“3. Withdraw Money”);
            System.out.println(“4. View Transaction History”);
            System.out.println(“0. Logout”);
            System.out.print(“Choose option: “);
            choice = sc.nextInt();

            switch (choice) {
                case 1 -> System.out.printf(“💰 Current Balance: ₹%.2f\n”, currentUser.getBalance());
                case 2 -> depositMoney();
                case 3 -> withdrawMoney();
                case 4 -> currentUser.showTransactionHistory();
                case 0 -> {
                    System.out.println(“🔓 Logged out.”);
                    currentUser = null;
                }
                default -> System.out.println(“❌ Invalid option.”);
            }
        } while (choice != 0 && currentUser != null);
    }

    private static void depositMoney() {
        System.out.print(“Enter amount to deposit: ₹”);
        double amount = sc.nextDouble();
        if (amount > 0) {
            currentUser.deposit(amount);
            System.out.println(“✅ Deposit successful!”);
        } else {
            System.out.println(“❌ Invalid amount.”);
        }
    }

    private static void withdrawMoney() {
        System.out.print(“Enter amount to withdraw: ₹”);
        double amount = sc.nextDouble();
        if (amount > 0) {
            if (currentUser.withdraw(amount)) {
                System.out.println(“✅ Withdrawal successful!”);
            } else {
                System.out.println(“❌ Insufficient balance.”);
            }
        } else {
            System.out.println(“❌ Invalid amount.”);
        }
    }
}
Scroll to Top