Memory Diagrams

Drawing pictures is helpful to understand how a program runs. A memory diagram is a picture that shows the contents of memory at a certain point in time. Specifically, a memory diagram shows variables (on the left) and objects (on the right).

Variables

A variable is drawn as a small box. The variable's name is on the left, and the variable's value is inside the box. The variable's type (optional) is above the box. For example, int count = 159; would be drawn as follows:

Java has eight primitive data types: byte, short, int, long, float, double, boolean, char. All other data types are defined by classes that represent objects. A reference is an integer that "points to" an object in memory. For example, a String variable refers to a String object:

As shown above, a reference is drawn as an arrow. The value of the mood variable is the memory location of the "happy" object. In contrast, the value of the count variable is the integer 159.

Note: null is not an object. The value null indicates a variable does not refer to an object. For example, Scanner in = null; would be drawn as follows:

Methods

A method is drawn as a large box. The method's name is on the left, and the method's variables are inside the box. For example, the diagram below shows the state of the program just before calling System.out.println():

public static void main(String[] args) {
    int hour = 11;
    int minute = 59;
    printTime(12, 15);
}

public static void print(int hour, int minute) {
    System.out.println(hour + ":" + minute);
}

Technically, main() also has a variable named args. But since command-line arguments are rarely used, the args variable is usually omitted from memory diagrams.

Arrays

An array variable refers to an array object. An array object is drawn as contiguous boxes. Indexes (optional) can be shown below the boxes. For example, double[] data = {1.2, 3.4, 5.6} is drawn as follows:

Each array element (such as data[0]) acts like a variable. If the element type is primitive, then the value is in the box. If the element type is a reference, then the value is an arrow. For example, String[] words = {"hello", "world"} looks like this:

Objects

An object is drawn as a large box. The object's attributes (variables) are inside the box. The object's type (optional) is above the box. For example:

public static void main(String[] args) {
    Point p1 = new Point(11, 12);
    Point p2 = new Point(13, 14);
}

Internally, a String object is an array of bytes. So the details of String pet = "dog"; could be drawn as follows:

For simplicity, String objects are usually drawn as a smaller box with a string in quotes. In fact, any object can be drawn as a String based on the object's toString() format:

public static void main(String[] args) {
    String pet = "dog";
    Point p1 = new Point(11, 12);
}

Static

static variables are initialized when a class is used for the first time, often before the main() method is called. Each class containing static variables is drawn on the left of the diagram. The following example shows two objects of the same class:

public class Person {

    private static int count = 0;

    private String name;
    private int pin;

    public Person(String name, int pin) {
        count++;
        this.name = name;
        this.pin = pin;
    }

    public static void main(String[] args) {
        Person p1 = new Person("Taylor", 1989);
        Person p2 = new Person("Travis", 8713);
    }

}

Note

The memory diagrams on this page are similar to, but not identical to, the diagrams drawn by Java Visualizer. Compare, for example, the Person diagram above with this visualization.