Java encapsulation: protect a wallet balance

Start with the rule the object must preserve

The wallet in this lesson stores whole credits, not real money. Its invariant is that the balance must never be negative. If balance were a public field, a caller could assign -100 directly and bypass every rule. Making the field private limits where it can be changed. The class can then check every operation that affects that state.

Private fields alone do not create good encapsulation. A public setBalance method that accepts any integer would reopen the same problem. Expose operations that describe the domain action instead: here a caller can ask to spend a positive number of credits and read the resulting balance.

Choose clear success and failure behaviour

The constructor rejects a negative opening balance by throwing IllegalArgumentException. The spend method uses a different policy: it returns false for an invalid or unaffordable amount and leaves the state unchanged. Either policy can be valid in an application, but callers need an explicit contract. Do not mutate state first and try to repair it after detecting failure.

The successful path subtracts only after both checks pass. Testing amount <= 0 prevents a negative spend from increasing the balance. Testing amount > balance prevents overspending. Spending the exact balance is allowed and leaves zero. These small boundary decisions are part of the object's behaviour, not incidental implementation details.

Test the invariant across a sequence

An object often receives several calls over its lifetime. Test a successful spend followed by an unaffordable spend, then inspect the balance. Checking only the boolean return is insufficient: a faulty method might return false after it has already changed the balance. Verify the state as well as the outcome.

This class is intentionally small and single-threaded. It is not a banking system and does not solve persistence or concurrent updates. Its purpose is to show one protected invariant. As requirements grow, add the necessary guarantees deliberately rather than assuming that the private keyword makes every operation safe in every environment.

Run the worked example

Save as Main.java. Run javac Main.java, then java Main.

class Wallet {
    private int balance;
    Wallet(int openingBalance) {
        if (openingBalance < 0) throw new IllegalArgumentException("Negative balance");
        balance = openingBalance;
    }
    boolean spend(int amount) {
        if (amount <= 0 || amount > balance) return false;
        balance -= amount;
        return true;
    }
    int getBalance() { return balance; }
}
public class Main {
    public static void main(String[] args) {
        Wallet wallet = new Wallet(100);
        System.out.println(wallet.spend(30));
        System.out.println(wallet.spend(80));
        System.out.println(wallet.getBalance());
    }
}

Expected result

true
false
70

1. The constructor establishes a valid initial state.
2. Spending 30 succeeds and leaves 70 credits.
3. Spending 80 fails before mutation, so 70 remains.

Try it yourself

Create a Counter with private int value starting at 0. A method increment increases it by one, and getValue returns it. Call increment twice and print 2.

class Counter {
    private int value;
    void increment() { value++; }
    int getValue() { return value; }
}
public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();
        counter.increment();
        counter.increment();
        System.out.println(counter.getValue());
    }
}

2

Quick check

Choose an answer, then check the explanation. Your answer stays in this page and is not saved as a student record.

Keep learning

Explain the result in your own words, change one input and predict the new output. For additional structured assignments, explore the workbook sample before requesting the full pack.