Payment interfaces and runtime polymorphism

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.

interface Payment { void pay(double amount); void refund(double amount); }
    static abstract class Ledger implements Payment {
        private double netPaid;
        static boolean valid(double amount) { return Double.isFinite(amount) && amount>0 && amount<=1000000; }

Payment declares pay and refund. Ledger is abstract and keeps netPaid private. Its valid method accepts only positive finite amounts up to the example limit. Concrete payment types must provide the public interface methods.

        void paid(double amount) { netPaid+=amount; }
        boolean refundable(double amount) { return valid(amount) && amount<=netPaid; }
        void refunded(double amount) { netPaid-=amount; }
    }

paid adds a successful payment to netPaid. refundable checks the amount and prevents refunding more than that net total. refunded subtracts only after a refund succeeds. This is per-object in-memory bookkeeping.

    static class UPIPayment extends Ledger {
        final String upiId, upiPin; private String enteredPIN=""; double balance;
        UPIPayment(String id,String pin,double balance) { upiId=id; upiPin=pin; this.balance=balance; }
        void enterPIN(String pin) { enteredPIN=pin; }

UPIPayment inherits ledger helpers and stores its identity, example PIN and balance. enterPIN sets the PIN supplied for the next attempted payment. These are demonstration values, not a real payment gateway connection.

        @Override public void pay(double amount) {
            boolean authenticated=upiPin.equals(enteredPIN); enteredPIN="";
            if (!valid(amount) || !authenticated || balance<amount) { System.out.println("UPI payment failed."); return; }
            balance-=amount; paid(amount); System.out.println("UPI payment success.");
        }

Compare strings with equals, then clear enteredPIN so it is not reused automatically. Reject a bad amount, wrong PIN or insufficient balance. Only success deducts balance and records paid(amount).

        @Override public void refund(double amount) {
            if (!refundable(amount)) { System.out.println("UPI refund failed."); return; }
            balance+=amount; refunded(amount); System.out.println("UPI refund success.");
        }
    }

Check the ledger before changing anything. On success credit balance and reduce netPaid. A failed payment does not create refundable funds.

    static class CardPayment extends Ledger {
        final String cardNumber,cardHolder,cvv; double limit;
        CardPayment(String number,String holder,String cvv,double limit) { cardNumber=number;cardHolder=holder;this.cvv=cvv;this.limit=limit; }
        @Override public void pay(double amount) {
            if (!valid(amount) || !cardNumber.matches("[0-9]{16}") || !cvv.matches("[0-9]{3}") || limit<amount) { System.out.println("Card payment failed."); return; }
            limit-=amount; paid(amount); System.out.println("Card payment success.");
        }

The card subtype stores a remaining limit and checks the example number/CVV formats as well as amount and available limit. A successful simulated payment reduces limit and records its refundable amount.

        @Override public void refund(double amount) {
            if (!refundable(amount)) { System.out.println("Card refund failed."); return; }
            limit+=amount; refunded(amount); System.out.println("Card refund success.");
        }
    }

Require refundable(amount), then add to limit and subtract from the ledger. Inherited validation keeps the refund total from exceeding previously successful payments.

    static class WalletPayment extends Ledger {
        final String walletId; double walletBalance;
        WalletPayment(String id,double balance) { walletId=id;walletBalance=balance; }
        @Override public void pay(double amount) {
            if (!valid(amount) || walletBalance<amount) { System.out.println("Wallet payment failed."); return; }
            walletBalance-=amount; paid(amount); System.out.println("Wallet payment success.");
        }

WalletPayment stores its own identity and balance. Reject invalid or unaffordable payments before changing the balance; otherwise deduct and record the payment.

        @Override public void refund(double amount) {
            if (!refundable(amount)) { System.out.println("Wallet refund failed."); return; }
            walletBalance+=amount; refunded(amount); System.out.println("Wallet refund success.");
        }
    }

An accepted refund credits walletBalance and lowers netPaid. The interface is shared with UPI/card, but each subtype applies changes to its own representation.

    // Demo-only: amount, entered UPI PIN, refund amount. Never enter real credentials.
    public static void main(String[] args) {
        try {
            double amount=number(0,1000000); String pin=text(); double refund=number(0,1000000);
            UPIPayment upi=new UPIPayment("demo@example","1234",1000); upi.enterPIN(pin);
            Payment[] methods={upi,new CardPayment("1111222233334444","Demo User","123",2000),new WalletPayment("DEMO-WALLET",500)};
            for (Payment payment:methods) { payment.pay(amount); payment.refund(refund); }

The input comment describes demo-only amount/PIN/refund fields. Construct three example objects, then call pay and refund on Payment references. Runtime dispatch selects each object’s implementation.

            money("UPI balance",upi.balance); money("Card remaining limit",((CardPayment)methods[1]).limit); money("Wallet balance",((WalletPayment)methods[2]).walletBalance);
        } catch (IllegalArgumentException e) { System.out.println("Invalid input: "+e.getMessage()); }
    }
}

The casts recover card and wallet subtype references for their demonstration fields. Print final balances/limits. The catch handles input-helper errors, while business-method rejection messages are printed inside those methods.