ATM withdrawal with a checked exception

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 InsufficientFundsException extends Exception {
        private static final long serialVersionUID=1L;
        InsufficientFundsException(String message){super(message);}
    }

The exception extends Exception and accepts a message passed to the parent constructor. The account method declares this checked failure explicitly.

    static class ATMAccount {
        final String accountNumber,holderName; private double balance;
        ATMAccount(String number,String name,double balance){accountNumber=number;holderName=name;this.balance=balance;}

ATMAccount has final identity strings and a private editable balance. The driver checks the initial balance before constructing the object.

        void withdraw(double amount) throws InsufficientFundsException {
            if(!Double.isFinite(amount)||amount<=0)throw new IllegalArgumentException("Amount must be positive.");
            if(amount>balance)throw new InsufficientFundsException("Insufficient funds; balance unchanged.");balance-=amount;
        }

A bad amount throws IllegalArgumentException. An amount exceeding balance throws InsufficientFundsException. Only after both checks pass is balance reduced, so an insufficient-funds attempt leaves it unchanged.

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

deposit validates the amount and resulting balance before adding. checkBalance returns the current balance without changing it. The last brace ends ATMAccount.

    // account-number/holder/opening-balance, then 1 amount=deposit, 2 amount=withdraw,
    // 3=balance, 0=exit; each value on its own line.
    public static void main(String[] args){
        try{
            ATMAccount account=new ATMAccount(text(),text(),number(0,1000000));
            while(true){
                int command=integer(0,3);if(command==0)break;

Input uses one field per line. Construct the account from checked data, then read commands 0–3. Exit breaks the loop; another command enters the nested try block.

                try{
                    if(command==1){account.deposit(number(0,1000000));System.out.println("Deposited.");}
                    else if(command==2){account.withdraw(number(0,1000000));System.out.println("Withdrawn.");}
                    else money("Balance",account.checkBalance());
                }catch(InsufficientFundsException e){System.out.println(e.getMessage());}
            }

Deposit, withdraw or display according to the command. Catch InsufficientFundsException around just this iteration. After its message the loop can read another command instead of ending the entire program.

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

The catch handles IllegalArgumentException, including invalid numeric strings from the helpers, and prints its message. The final braces close main and Main. Java objects become eligible for garbage collection when no live reference needs them; this program does not manually free them.