Creating and using objects

Written Explanation

Creating and using

A complete use of a class has three parts: declare a variable, create the object with new, and use it through the dot.

Account ana = new Account("Ana", "A-1", 100);
ana.deposit(50);
System.out.println(ana.describe());

new Account(...) creates the object and runs the constructor. According to the Java tutorial, new allocates memory for the object and returns a reference to it. The assignment stores that reference in ana. After that, ana.deposit(50) means "follow the reference and run deposit on the object found there".

The variable declaration and the creation are separate things. Account x; alone creates no object. The variable x exists, but it points to nothing, and if it is a local variable, Java will not even let you use it before it is assigned:

U.java:1: error: variable x might not have been initialized

You do not always have to store the reference. new Account("Tmp", "T-0", 1).deposit(5); creates an object and uses it once. Nobody can reach it afterwards, so this is useful only for rare one-off calls.

Two variables, one object

Because the variable holds a reference, copying the variable copies the reference:

Account ana = new Account("Ana", "A-1", 100);
Account alias = ana;
alias.deposit(25);
System.out.println(ana.balance);

This prints 125.0. There is one account object, with two names for it. alias.deposit(25) followed the arrow to that single object. This is the picture to keep in your head:

ana   ----\
           +--> [ Account: Ana, A-1, 125.0 ]
alias ----/

Reassigning a variable only moves its arrow and does not change the object. After alias = new Account("Bea", "B-1", 0);, alias points to a new object, and ana still points to the old one. Primitives behave differently: int a = 5; int b = a; copies the number itself, so changing b never affects a. That is why object variables need extra care.

The same holds when you pass an object to a method. The parameter is a copy of the reference, so the method can change the object that the caller sees:

static void restockLikeThis(Product p) {
    p.stock = 100;      // changes the caller's object
}

(The method cannot, however, make the caller's variable point somewhere else.)

== compares references

For objects, == asks "do both variables point to the same object?", not "do the objects hold the same data":

Account twin = new Account("Ana", "A-1", 125);
System.out.println(ana == alias);   // true:  same object
System.out.println(ana == twin);    // false: two objects, equal contents

Equal-looking contents do not make == true. Later modules teach how to define "equal contents" with equals; for now, remember that == on objects is about identity. You already met this with String in the arrays and strings module.

null: pointing at nothing

null is the reference that points to no object. It is the default for every object-typed field, and you can assign it yourself. You can store it, compare it (x == null), and print it, but you cannot follow it. Calling a method or reading a field through null throws NullPointerException. The Java documentation lists exactly these situations: calling an instance method on null, accessing a field of null, and using null as an array.

Product c = new Product("Tea", 2.5, 10);
c = null;
System.out.println(c.stock);

Exception in thread "main" java.lang.NullPointerException: Cannot read field "stock" because "c" is null
	at Main.main(Main.java:14)

Modern JDKs describe what was null in the message. Combine it with the line number in the stack trace and you can find the cause quickly. (Names such as c appear when the code is compiled with debugging information, which IDEs normally do; otherwise you may see placeholders like <local4>.) The fix is never to catch the exception and move on: find out why the variable was null and make sure it holds an object, or check if (c != null) where null is a legitimate state.

Arrays of objects

An array of objects is an array of references. Creating the array does not create any objects:

Account[] all = new Account[2];     // two slots, both null
all[0] = new Account("Omar", "A-2", 80);
System.out.println(all[0].describe());   // works
System.out.println(all[1].describe());   // NullPointerException: all[1] is null

Each slot must be filled with new before use. When every slot is filled, a loop works as always: for (Account acc : all) { acc.deposit(10); }.