1.13 Object Creation and Storage (Instantiation)

1. Constructors and constructor signatures

A class contains constructors that are called to create objects. They have the same name as the class 1.13.A.1.

A constructor signature is the constructor’s name (the same as the class name) plus the ordered list of parameter types. In the constructor header, the parameter list gives the type and the variable name of each value passed in 1.13.A.2.

Constructors are overloaded when a class has several constructors with different signatures 1.13.A.3. The Plant class used on these pages has 2 constructors:

Constructor header	Signature	What it does
public Plant(String n)	Plant(String)	name n, height starts at 0
public Plant(String n, int h)	Plant(String, int)	name n, height h

Java picks the constructor by comparing the argument types with the parameter types, in order:

Plant p = new Plant("Fern", 30); // calls Plant(String, int)
Plant q = new Plant("Mint");     // calls Plant(String): height 0
System.out.println(p.getHeight());
System.out.println(q.getHeight());

Output:

30
0

Two constructors with the same parameter types, such as Box(int side) and Box(int len), do not compile, because their signatures are the same (Box(int)):

// does not compile
public class Box
{
    private int size;
    public Box(int side) { size = side; }
    public Box(int len) { size = len; }
}

Real view:

error: constructor Box(int) is already defined in class Box

2. Variables that hold object references

A variable of a reference type holds an object reference or, if there is no object, null 1.13.B.1. The variable’s type is the class name.

Plant r = null;                 // r refers to no object
System.out.println(r);
r = new Plant("Sage", 8);       // now r refers to a Plant
System.out.println(r.getName());

Output:

null
Sage

3. Creating an object with new

An object is typically created with the keyword new followed by a call to one of the class’s constructors 1.13.C.1. Parameters allow constructors to accept values that set the initial values of the object’s attributes 1.13.C.2.

Reading Plant p = new Plant("Fern", 30); part by part:

Part	Meaning
Plant (first)	the class: the reference type of the variable
p	the variable that will hold the reference
=	assignment: store the reference in p
new	the keyword that creates the object
Plant("Fern", 30)	the constructor call: same name as the class; it runs, then control returns here
"Fern", 30	the arguments, copied into the parameters n and h

4. Constructor arguments

A constructor argument is a value passed into a constructor when it is called. The arguments must be compatible in order and number with the types in the parameter list of the constructor signature. Arguments are passed using call by value: the parameters are initialized with copies of the arguments 1.13.C.3. An int argument can go to a double parameter, because the int is widened to a double (topic 1.5).

public class Ticket
{
    public Ticket(String event, double price)
    {
        System.out.println(event + " ticket: " + price);
    }

    public Ticket(double price)
    {
        System.out.println("General ticket: " + price);
    }

    public Ticket(int seat, String event)
    {
        System.out.println(event + " seat " + seat);
    }
}

// in main
Ticket a = new Ticket("Gala", 40);
Ticket b = new Ticket(15.5);
Ticket c = new Ticket(12, "Gala");

Output:

Gala ticket: 40.0
General ticket: 15.5
Gala seat 12

new Ticket("Gala", 40) has a String then an int. Only Ticket(String, double) has a String first, and 40 is widened to 40.0.

Watch out: order matters. new Plant(30, "Fern") does not compile, because no Plant constructor takes an int first:

// does not compile
Plant f = new Plant(30, "Fern");

Real view:

error: incompatible types: int cannot be converted to String

The only Plant constructor with two parameters is Plant(String, int), and its first parameter needs a String, not the int 30.

5. Flow of control in a constructor call

A constructor call interrupts the sequential execution of statements: the program first runs the statements in the constructor. Once the last statement in the constructor has run, the flow of control returns to the point immediately after the constructor call 1.13.C.4.

Here a version of the Plant constructor also prints:

public class Plant
{
    private String name;
    private int height;

    // a version of the Plant constructor that also prints
    public Plant(String n, int h)
    {
        name = n;
        height = h;
        System.out.println("Made " + n);
    }

    public int getHeight()
    {
        return height;
    }
}

// in main
System.out.println("Start");
Plant f = new Plant("Fern", 30);
System.out.println(f.getHeight());

Output:

Start
Made Fern
30

Start prints first. The constructor call then runs every statement in the constructor (printing Made Fern), and control comes back to the next line, which prints 30.