🧪 Building a Simple Bank System using Inheritance and Encapsulation

[akash-coded]

🧪 Title: Building a Simple Bank System using Inheritance and Encapsulation

Filename: SimpleBankSystem.java
Goal: Reinforce class relationships, constructors, encapsulated fields, inheritance, and clean code practices.

---

🧾 Background:

You're part of a small fintech startup. The product is a basic bank account system. You need to implement:

• A base class Account for all types of accounts
• A subclass SavingsAccount that inherits from Account
• A further subclass JuniorSavingsAccount that inherits from SavingsAccount
• A test class BankDemo that uses all the classes
• Practice sections where students write both the non-optimized and optimized versions

---

💡 Instructions:

You’ll complete the TODOs in the code below. Follow the JavaDoc-style comments to understand the purpose of each method.

Use meaningful variable names, and follow Java conventions (camelCase, PascalCase for class names).

---

🧑‍💻 Starter Code – SimpleBankSystem.java

/**
 * The base class for all types of bank accounts.
 */
class Account {

    // Use encapsulation: keep fields private
    private String accountHolderName;
    private double balance;

    /**
     * Constructor to initialize the account.
     */
    public Account(String name, double initialBalance) {
        // TODO 1: Set the accountHolderName and initial balance using setters or directly.
        this.accountHolderName = name;
        this.balance = initialBalance;
    }

    /**
     * Deposits money into the account.
     */
    public void deposit(double amount) {
        // TODO 2: Add validation - only positive amounts allowed
        if (amount > 0) {
            balance += amount;
            System.out.println("Deposited ₹" + amount);
        } else {
            System.out.println("❌ Invalid deposit amount.");
        }
    }

    /**
     * Withdraws money from the account, if sufficient balance exists.
     */
    public void withdraw(double amount) {
        if (amount > balance) {
            System.out.println("❌ Not enough balance.");
        } else {
            balance -= amount;
            System.out.println("Withdrawn ₹" + amount);
        }
    }

    // Getters for encapsulated fields
    public String getAccountHolderName() {
        return accountHolderName;
    }

    public double getBalance() {
        return balance;
    }

    public void printAccountDetails() {
        System.out.println("👤 Account Holder: " + accountHolderName);
        System.out.println("💰 Balance: ₹" + balance);
    }
}

/**
 * Inherits from Account. Represents a savings account.
 */
class SavingsAccount extends Account {

    // Fill in the blank: add a private field for interestRate
    private double interestRate;

    public SavingsAccount(String name, double balance, double interestRate) {
        // TODO 3: Call the constructor of Account class
        super(name, balance);
        this.interestRate = interestRate;
    }

    /**
     * This method adds interest to the balance.
     */
    public void addInterest() {
        double interest = getBalance() * (interestRate / 100);
        // No method overriding: use deposit() directly
        deposit(interest); // Calling base class method
        System.out.println("📈 Interest of ₹" + interest + " added.");
    }

    public void showSavingsInfo() {
        System.out.println("Interest Rate: " + interestRate + "%");
    }
}

/**
 * Inherits from SavingsAccount. Represents a junior account with spending limits.
 */
class JuniorSavingsAccount extends SavingsAccount {

    private double dailyLimit;

    public JuniorSavingsAccount(String name, double balance, double interestRate, double limit) {
        // TODO 4: Call parent constructor
        super(name, balance, interestRate);
        this.dailyLimit = limit;
    }

    /**
     * Withdraw with a daily limit check (no overriding).
     */
    public void withdrawWithLimit(double amount) {
        // TODO 5: Check limit and call base withdraw() method
        if (amount > dailyLimit) {
            System.out.println("❌ Exceeds daily limit of ₹" + dailyLimit);
        } else {
            withdraw(amount); // from base class
        }
    }

    public void printLimitInfo() {
        System.out.println("🛡️ Daily withdrawal limit: ₹" + dailyLimit);
    }
}

/**
 * The driver class with main method.
 */
public class BankDemo {

    public static void main(String[] args) {

        // 🧪 PART 1: Non-optimized code
        System.out.println("🔧 Non-Optimized:");
        Account acc1 = new Account("Ravi", 5000);
        acc1.printAccountDetails();
        acc1.deposit(2000);
        acc1.withdraw(10000); // Exceeds balance
        acc1.withdraw(1500);
        System.out.println("Final Balance: ₹" + acc1.getBalance());

        // 🧪 PART 2: Optimized code with good naming and comments
        System.out.println("\n🛠️ Optimized:");

        SavingsAccount savings = new SavingsAccount("Meena", 10000, 4.5);
        savings.printAccountDetails();
        savings.deposit(5000);
        savings.addInterest(); // Apply interest
        savings.showSavingsInfo();

        JuniorSavingsAccount junior = new JuniorSavingsAccount("Tina", 3000, 3.5, 2000);
        junior.printAccountDetails();
        junior.printLimitInfo();
        junior.withdrawWithLimit(2500); // should be blocked
        junior.withdrawWithLimit(1500); // should go through

        System.out.println("\n✅ End of Transactions.");
    }
}

---

🏗 Key Concepts Reinforced:

• Inheritance: SavingsAccount → Account, JuniorSavingsAccount → SavingsAccount
• Encapsulation: All fields are private + getters/setters used
• Constructor chaining using super(...)
• No overriding: Simpler inheritance with explicit method usage
• Code improvement: Compare non-optimized and optimized usage
• Beginner comfort: No polymorphism or abstract/interface usage yet

---

📌 Suggested Student Practice (after this task):

1. Add setInterestRate() to allow changing interest.
2. Add a method to transfer money between two Account objects.
3. Create a new class FixedDepositAccount (inherit from Account) with a lockInPeriod field.
4. Rewrite withdraw() so it returns boolean to check success/failure (no print inside).

[Sdey0907]

Task 1 - Sayan Dey  

// Base Class: Account
class Account {
    private String accountNumber;
    protected double balance;

    public Account(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }

    public void deposit(double amount) {
        balance += amount;
        System.out.println("Deposited: " + amount);
    }

    public void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
            System.out.println("Withdrawn: " + amount);
        } else {
            System.out.println("Insufficient balance!");
        }
    }

    public double getBalance() {
        return balance;
    }
}

// Subclass: SavingsAccount
class SavingsAccount extends Account {
    private double interestRate;

    public SavingsAccount(String accountNumber, double initialBalance, double interestRate) {
        super(accountNumber, initialBalance);
        this.interestRate = interestRate;
    }

    public void addInterest() {
        balance += balance * interestRate / 100;
        System.out.println("Interest added.");
    }
}

// Subclass: JuniorSavingsAccount
class JuniorSavingsAccount extends SavingsAccount {
    private String nomineeName;

    public JuniorSavingsAccount(String accountNumber, double initialBalance, double interestRate, String nomineeName) {
        super(accountNumber, initialBalance, interestRate);
        this.nomineeName = nomineeName;
    }

    @Override
    public void withdraw(double amount) {
        System.out.println("Nominee approval needed for money withdrawal.");
    }
}
public class Main {
    public static void main(String[] args) {
        Account acc = new Account("12345", 1000);
        SavingsAccount savings = new SavingsAccount("67890", 2000, 5);
        JuniorSavingsAccount junior = new JuniorSavingsAccount("13579", 1500, 3, "Sayan Dey");

        acc.deposit(500);
        acc.withdraw(300);
        System.out.println("Account balance: " + acc.getBalance());

        savings.addInterest();
        System.out.println("Savings Account balance: " + savings.getBalance());

        junior.withdraw(200);
    }
}

[prasetha21-max]

PRASETHA N

public class Account {
    private String accountHolder;
    private String accountNumber;
    protected double balance;

    public Account(String accountHolder, String accountNumber, double initialDeposit) {
        this.accountHolder = accountHolder;
        this.accountNumber = accountNumber;
        this.balance = initialDeposit;
    }

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

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("Withdrawn: $" + amount);
        } else {
            System.out.println("Invalid withdrawal amount.");
        }
    }

    public double getBalance() {
        return balance;
    }

    public String getAccountInfo() {
        return "Account Holder: " + accountHolder +
               ", Account Number: " + accountNumber +
               ", Balance: $" + balance;
    }
}
public class SavingsAccount extends Account {
    private double interestRate;

    public SavingsAccount(String accountHolder, String accountNumber, double initialDeposit, double interestRate) {
        super(accountHolder, accountNumber, initialDeposit);
        this.interestRate = interestRate;
    }

    public void applyInterest() {
        double interest = balance * (interestRate / 100);
        deposit(interest);
        System.out.println("Interest applied: $" + interest);
    }
}
public class JuniorSavingsAccount extends SavingsAccount {
    private static final double MAX_WITHDRAWAL = 100.0;

    public JuniorSavingsAccount(String accountHolder, String accountNumber, double initialDeposit, double interestRate) {
        super(accountHolder, accountNumber, initialDeposit, interestRate);
    }

    @Override
    public void withdraw(double amount) {
        if (amount > MAX_WITHDRAWAL) {
            System.out.println("Withdrawal exceeds junior account limit of $" + MAX_WITHDRAWAL);
        } else {
            super.withdraw(amount);
        }
    }
}
public class BankDemo {
    public static void main(String[] args) {
        System.out.println("=== Regular Account ===");
        Account regular = new Account("Ram", "1", 500.0);
        regular.deposit(200);
        regular.withdraw(100);
        System.out.println(regular.getAccountInfo());

        System.out.println("\n=== Savings Account ===");
        SavingsAccount savings = new SavingsAccount("Mohan", "2", 1000.0, 5.0);
        savings.applyInterest();
        savings.withdraw(50);
        System.out.println(savings.getAccountInfo());

        System.out.println("\n=== Junior Savings Account ===");
        JuniorSavingsAccount junior = new JuniorSavingsAccount("Beth", "3", 300.0, 4.0);
        junior.withdraw(150);
        junior.withdraw(80);
        junior.applyInterest();
        System.out.println(junior.getAccountInfo());
    }
}