Creating Objects with the new Keyword

Many beginners describe an object variable as a container, a labeled box with an object placed inside it. The phrase sounds reasonable, and many people use it without thinking. In Java, however, that picture is not accurate. The difference matters as soon as a program works with several objects at once, because the box picture predicts behavior that the language does not actually produce.

Consider the simplest case: a variable of class type Student is declared, and then a new object is created and assigned to it. The statement below is the one the source uses to illustrate the idea.

Read the second line as two separate jobs. One part creates the Student object in the heap. The other part records a reference to that object in std. Once the line has finished, std is not the object. It is the means of reaching the object. When the program later uses std, the computer reads the reference stored there and follows it to the object.

Objects live in a special region of memory called the heap, and they exist independently of the variables that use them. Think of an object as floating in the heap rather than attached to any one variable. A variable of object type holds a reference, which the source also calls a pointer, to the object. A reference is the address of the memory location where the object is stored. The computer follows that address whenever the program uses the variable.

The diagram shows the correct structure. The variable and the object are two separate things joined by a link. The object is not drawn inside the variable, because the variable does not contain it. The variable is a small holder for a reference, while the object can be much larger, since it sits in the heap rather than inside the variable itself.

The new operator is the mechanism that brings an object into existence. When you write new followed by a class name and parentheses, the operator does two things. It creates an object that is an instance of that class, and it returns a reference to that object. The returned reference is the value that gets stored. The created object and the reference that points to it are separate things.

The operator also does more work behind the scenes. It calls a special subroutine defined in the class, called a constructor. The constructor is the part of the class responsible for setting up a new instance. You do not call the constructor as a separate step, because the new operator invokes it as part of creating the object. Read the sequence as messages in order. The new operator hands control to the constructor, the constructor finishes creating the object, and only then does a reference come back to be stored. The variable receives the reference, not the object.

Once a reference is stored, copying it into another variable copies the reference, not the object. Both variables then refer to the same object. This is the reason the reference model matters: a change made through one variable is visible through the other, because both lead to one object.

Now trace a sequence of statements. Predict, line by line, what each variable refers to before you read the explanation that follows each step. This example is written for this article and extends the single-declaration case from the source.