Demo: static vs instance, seen in the debugger

Written Explanation

The program

Use the Account class from Lesson 6, with its static count incremented in the full constructor. Replace Main with this:

public class Main {
    public static void main(String[] args) {
        Account a = new Account("Ana", "A-1", 100);
        Account b = new Account("Omar", "A-2", 40);
        Account c = new Account("Sara", "A-3", 7);
        System.out.println(Account.count);
        System.out.println(c.count);
    }
}

Running it prints (JDK 21):

3
3

Both lines print 3. The second line reads count through c, which compiles but is discouraged; it shows that no matter which object you use, you reach the same single variable. We will confirm that in the debugger.

Step 1: add the counter

If your Account has no counter yet, add static int count = 0; at the top of the class and count++; at the end of the full constructor. Compile and run to check that the output above is what you get.

Step 2: breakpoint after the third object

Set a breakpoint on the first System.out.println line (in most IDEs you click next to the line number). Start the program in debug mode, not the normal run mode, which is usually a separate button or menu item. The program runs and pauses at the breakpoint, before that line executes. By now three accounts exist.

Step 3: read the variables view

Find the panel that lists variables (names vary: Variables, Locals, or similar). You should see three local variables a, b, c, and args. Expand a, b, and c. The exact layout depends on your IDE, but you should see, per object, its instance fields:

Three objects, three separate sets of values. Each balance belongs to its own object, as Lesson 1 said.

Now look for count. Depending on the IDE, it appears in one of two ways: in a separate section of the variables view labelled "static" (or similar) when you expand the object or the class, or after you add a watch or evaluate expression for Account.count (a tool from the debugging module). It is not listed inside each object as a separate value, because there is only one count. Its value is 3. Evaluating Account.count and c.count gives the same number, because both mean the one shared variable. If your debugger shows count while expanding an object, the value is the same for all three, and that is the reason: it is not a per-object field.

A mental picture of what you see:

Class Account (one place):    count = 3

Object a:  owner=Ana   number=A-1  balance=100.0
Object b:  owner=Omar  number=A-2  balance=40.0
Object c:  owner=Sara  number=A-3  balance=7.0

Step 4: step through and watch the counter

Restart in debug mode, and this time put the breakpoint on the first new. Add a watch on Account.count. Use the "step over" command (from the debugging module) one line at a time. The watch shows 0 before the first new, 1 after, then 2, then 3. The constructor changes the shared variable each time. If your IDE lets you step into the constructor, you can also see this listed as the object being built, which makes Lesson 3's idea of "the current object" visible.

Step 5: the planned mistake

Stop the program. In Account, change double balance; to static double balance; and fix the constructor line to Account.balance = balance; so that it compiles. (Writing this.balance for a static field also compiles, but it hides the fact that the field is shared, so we use the class name.) Run the Lesson 6 Main again. The output is:

Ana (A-1): 70.0
Omar (A-2): 70.0
Second withdrawal ok? false
Accounts created: 2

Both accounts show 70.0. Debug it as you did before. In the variables view, the objects no longer show a balance of their own. It has moved to the class-level data, next to count: one balance for the whole class. Ana's 100 went in first; Omar's 0 overwrote it; then Ana's 50 deposit and Omar's 20 deposit changed the same variable, so it ended at 70 for everyone.

Remove static from balance and restore this.balance = balance;. The output goes back to 150.0 and 20.0, and the debugger shows a balance per object again.

Step 6: summarize

• One per object means instance: it appears under each object in the debugger.
• Shared across all means static: it appears once, at class level.
• If values that should be independent change together, a field is probably static by mistake. Check the field's declaration first.