Private State & Methods

A private field cannot be accessed directly from another top-level class. Public methods can expose useful operations without exposing every internal assignment. This is encapsulation: the object owns rules about its state. A getter reads a field; a setter assigns one. You do not need either automatically for every field. The public operations form the class’s API: what other code can call and the behavior it can rely on.

A session’s planned duration can stay fixed while completion changes. Instead of allowing any caller to write done, expose complete(). Calling it twice should still mean completed, not toggle the state back or add time twice. This operation is idempotent: repeating it has the same final effect as doing it once.

Choose what callers should be able to do

Return information through methods such as remaining(), and update state through methods named after an action. A method returning false can report that a proposed change was rejected. On Day 6, exceptions will offer another way to signal invalid input. Both approaches need a clear rule about whether state changed.

The keyword public allows the model’s methods to be called by other classes. For now, keep all classes in the supplied workspace and use public for the operations intended for callers, and private for the data they should not assign directly. Other access rules can wait until you need to organize a larger project.

public class Main {
    public static void main(String[] args) {
        Session session = new Session(25);
        System.out.println(session.remaining());

        session.complete();
        session.complete();

        System.out.println(session.remaining());
    }
}

class Session {
    private final int minutes;
    private boolean done;

    Session(int minutes) {
        this.minutes = minutes;
    }

    public void complete() {
        done = true;
    }

    public int remaining() {
        if (done) {
            return 0;
        }

        return minutes;
    }
}

25
0

The completion operation assigns a fact; it does not flip the boolean. The second call leaves the same state as the first. A caller can ask for remaining time without learning how the boolean is stored.

public class Main {
    public static void main(String[] args) {
        Budget budget = new Budget();
        System.out.println(budget.add(-5));
        System.out.println(budget.add(10));
        System.out.println(budget.total());
    }
}

class Budget {
    private int minutes;

    public boolean add(int amount) {
        if (amount < 0) {
            return false;
        }

        minutes += amount;
        return true;
    }

    public int total() {
        return minutes;
    }
}

false
true
10

Validation occurs before mutation. If you added the amount before testing it, the false result would conceal a changed budget. The contract includes both the returned boolean and the state afterward.

public class Main {
    public static void main(String[] args) {
        Secret secret = new Secret();
        System.out.println(secret.value);
    }
}

class Secret {
    private int value = 25;
}

Your turn

public class Main {
    public static void main(String[] args) {
        // Use methods to change and inspect the counters.
    }
}

class Counter {
    private int count;
    // Define the public operations.
}

public class Main {
    public static void main(String[] args) {
        Counter first = new Counter();
        Counter second = new Counter();

        first.increment();
        first.increment();

        System.out.println(first.current());
        System.out.println(second.current());
    }
}

class Counter {
    private int count;

    public void increment() {
        count++;
    }

    public int current() {
        return count;
    }
}

2
0

Change it and explain

Add a reset() method and write a check that resetting one object does not affect another. Then decide whether reset is part of the actual brief or an optional extension: a smaller API can be easier to understand and test.

Use methods to enforce meaningful rules, not just to disguise arbitrary assignment. A complete() method communicates more intent than setDone(boolean) when the project never needs to make a completed session incomplete.