Bank accounts and encapsulated operations

import java.util.*;

public class Main {
    private static final Scanner IN = new Scanner(System.in).useLocale(Locale.ROOT);

java.util.* imports utility type names such as Scanner, Locale and collections. Main is the public class matching Main.java. The private static final IN field holds one shared Scanner for System.in; final prevents replacing that reference. The scanner uses Locale.ROOT.

    static String text() {
        if (!IN.hasNextLine()) throw new IllegalArgumentException("Incomplete input.");
        String value = IN.nextLine().trim();
        if (value.isEmpty() || value.length() > 200) throw new IllegalArgumentException("Text must have 1–200 characters.");
        return value;
    }

text checks whether a line exists, reads it and removes leading/trailing whitespace. Reject empty text and lengths above 200 by throwing IllegalArgumentException. Otherwise return the string. One field is read per line, so these helpers do not mix nextInt with leftover newlines.

    static int integer(int low, int high) {
        int value = Integer.parseInt(text());
        if (value < low || value > high) throw new IllegalArgumentException("Integer out of range.");
        return value;
    }

Integer.parseInt converts the returned string to int or throws NumberFormatException, a subtype of IllegalArgumentException. Reject values outside the caller’s inclusive low/high limits, then return the accepted integer.

    static double number(double low, double high) {
        double value = Double.parseDouble(text());
        if (!Double.isFinite(value) || value < low || value > high) throw new IllegalArgumentException("Number out of range.");
        return value;
    }

Double.parseDouble reads the string as a double. Double.isFinite rejects NaN and infinities as well as the explicit low/high range check. Return only a finite accepted value; exceptions transfer control to a matching catch block.

    static void money(String label, double value) { System.out.printf(Locale.ROOT, "%s: %.2f%n", label, value); }

money is a formatting helper: %s prints the label, %.2f prints two decimal places, and %n ends the line. Locale.ROOT fixes locale-sensitive formatting. The helper can also display non-currency quantities; it does not change the stored value.

static class BankAccount {
        private final String accountHolder, accountNumber, accountType;
        private double balance;

Each BankAccount has final identity strings and a private balance. Identity references are assigned once; balance changes only through the methods supplied by this example.

        BankAccount(String holder, String account, double balance, String type) {
            if (!Double.isFinite(balance) || balance < 0 || balance > 1000000) throw new IllegalArgumentException("Invalid opening balance.");
            this.accountHolder = holder; this.accountNumber = account; this.balance = balance; this.accountType = type;
        }

Require a finite balance from 0 to 1,000,000, then assign holder, account number, balance and type. Account numbers remain strings so leading zeros can be retained.

        void deposit(double amount) {
            if (!Double.isFinite(amount) || amount <= 0 || balance + amount > 1000000000) throw new IllegalArgumentException("Invalid deposit.");
            balance += amount;
        }

deposit requires a positive finite amount and caps the resulting balance. Only after every check passes does balance += amount change the object.

        boolean withdraw(double amount) {
            if (!Double.isFinite(amount) || amount <= 0) throw new IllegalArgumentException("Invalid withdrawal.");
            if (amount > balance) return false; balance -= amount; return true;
        }

A nonpositive or non-finite amount throws an exception. A valid amount above the balance returns false without deduction. Otherwise subtract it and return true.

        double checkBalance() { return balance; }
        double calculateInterest(float rate) {
            if (!Float.isFinite(rate) || rate < 0 || rate > 100) throw new IllegalArgumentException("Invalid rate.");
            return balance * rate / 100;
        }

checkBalance returns the stored amount. calculateInterest validates its float rate and computes balance*rate/100 for one year. Returning the interest does not deposit it or modify balance.

        void display() { System.out.println(accountNumber + " | " + accountHolder + " | " + accountType); money("Balance", balance); }
    }

Print the identity line, then the current balance. The brace closes BankAccount.

    // Two accounts: holder/number/balance/type each. Then 1 id amount=deposit,
    // 2 id amount=withdraw, 3 id=balance, 4 id rate=annual interest, 0=exit. IDs 1 or 2.
    public static void main(String[] args) {
        try {
            BankAccount[] accounts = new BankAccount[2];
            for (int i = 0; i < 2; i++) accounts[i] = new BankAccount(text(), text(), number(0, 1000000), text());

main constructs exactly two BankAccount objects from holder/number/balance/type lines. The array stores their references, not two aliases to the same object.

            while (true) {
                int command = integer(0, 4); if (command == 0) break;
                BankAccount account = accounts[integer(1, 2) - 1];

Command 0 exits the loop. Other commands require ID 1 or 2; subtract one after validation to obtain an array index.

                if (command == 1) { account.deposit(number(0, 1000000)); System.out.println("Deposited."); }
                else if (command == 2) System.out.println(account.withdraw(number(0, 1000000)) ? "Withdrawn." : "Denied: insufficient funds.");
                else if (command == 3) account.display();
                else money("Annual interest (not credited)", account.calculateInterest((float)number(0, 100)));

Methods operate on the selected account. A failed withdrawal prints a denial. The interest branch casts the accepted rate to float and labels the returned interest as not credited.

            }
        } catch (IllegalArgumentException e) { System.out.println("Invalid input: " + e.getMessage()); }
    }
}

The first brace ends the loop. The catch prints invalid-input messages; the remaining braces close main and Main. An insufficient-funds false result does not reach this catch.