عرض عملي: رسم stack وheap ثم التحقق في المصحّح (debugger)

Written Explanation

The workflow: draw, predict, run, compare

Follow the same five steps for every program:

1. Read the program once without running it.
2. Draw frames and heap at the point you care about (a chosen line).
3. Predict the values the program will print and the variables the debugger will show.
4. Run it with a breakpoint on that line.
5. Compare. Where the debugger and the drawing disagree, the debugger is right. Change the drawing and write down what you misunderstood.

This is the habit that matters, not the tool.

What the debugger shows

Debuggers differ between IDEs, and menus, shortcuts, and panel names vary by IDE and version, so use your IDE's help if a name here does not match. Typically you will find:

• a gutter next to the line numbers where a click sets a breakpoint (execution pauses before that line runs),
• a Debug (or Run in debug mode) action next to the usual Run,
• step over (run the current line, stay in this method), step into (enter the method being called), and resume (run to the next breakpoint),
• a frames or call stack list, with the newest frame on top,
• a variables panel for the selected frame.

For primitives the panel shows the value. For object variables it usually shows the type, a short description such as the contents of a list, and often an identifier such as @ followed by a number. That identifier is a debugger label for the object, and it differs from run to run and between IDEs. If two variables show the same label, they refer to the same object.

Reading the stack in the debugger

The frames list is the stack from lesson 1, shown as text. When the debugger pauses inside addAgain, the list shows addAgain on top and main below it. Selecting main in that list switches the variables panel to main's slots, so you can compare both frames at the same moment. This is the quickest way to see that a parameter and the caller's variable are two different slots that may hold the same reference.

A good first drawing is small. For this demo, three things are worth tracking: the two integers, the one list that a and b share, and the extra list created inside addAgain. Do not draw the internals of ArrayList (its internal array and size field). They are real, but they distract from the question you are answering, which is who points to what.

Finally, decide in advance which line you will pause on. Pausing on the last line of a method gives a different drawing from pausing on the first, because a frame's slots fill in as the lines run.

Our program

import java.util.*;
public class L05 {
    static void addAgain(List<String> l) {
        l.add("c");
        l = new ArrayList<>();
        l.add("lost");
    }
    public static void main(String[] args) {
        int count = 2;
        int copy = count;
        copy = 3;
        List<String> a = new ArrayList<>();
        List<String> b = a;
        a.add("a");
        b.add("b");
        addAgain(a);
        System.out.println(a + " " + b + " " + (a == b));
        b = null;
        System.out.println(count + " " + copy + " " + a + " " + b);
    }
}