3.4 Constructors

1. State: what an object has, right now

An object’s state is its attributes and their values at a given time. The state is defined by the instance variables that belong to the object 3.4.A.1. This is a has-a relationship: a player has a name, has a score and has a level 3.4.A.1.

public class Player
{
    private String name;
    private int score;
    private int level;

    /** Creates a player at level 1 with a score of 0 */
    public Player(String playerName)
    {
        name = playerName;
        score = 0;
        level = 1;
    }

    /** Creates a player at startLevel with a score of 0 */
    public Player(String playerName, int startLevel)
    {
        name = playerName;
        score = 0;
        level = startLevel;
    }

    public void addPoints(int points)
    {
        score += points;
        if (score >= 100)
        {
            level++;
            score -= 100;
        }
    }

    public String getName()
    {
        return name;
    }

    public int getScore()
    {
        return score;
    }

    public int getLevel()
    {
        return level;
    }

    public String toString()
    {
        return name + " L" + level + " " + score + " pts";
    }
}

Player ana = new Player("Ana");
System.out.println(ana);
ana.addPoints(70);
System.out.println(ana);
ana.addPoints(45);
System.out.println(ana);

Output:

Ana L1 0 pts
Ana L1 70 pts
Ana L2 15 pts

Background: println(ana) shows the text built by the class’s toString method. You will read toString in class code, but writing one is outside the AP® exam.

The state changes over time:

Moment	name	score	level
After new Player("Ana")	“Ana”	0	1
After addPoints(70)	“Ana”	70	1
After addPoints(45)	“Ana”	15	2

2. Writing a constructor

A constructor sets the initial state of an object, and that should include an initial value for every instance variable 3.4.A.2. Constructor parameters, if there are any, provide the data used to initialize the instance variables 3.4.A.2.

When a constructor is called with new, memory is allocated for the object and the reference to the new object is returned 3.4.A.2. The variable stores that reference, not the object itself.

Player p1 = new Player("Ana");
Player p2 = new Player("Ben", 5);
System.out.println(p1.getLevel() + " " + p2.getLevel());

Output:

1 5

Memory after these lines:

p1 [ ref ] ---> Player object:  name "Ana"   score 0   level 1
p2 [ ref ] ---> Player object:  name "Ben"   score 0   level 5

Player has two constructors with different parameter lists (overloaded constructors). Java chooses the one whose parameters match the arguments.

Watch out: a constructor has the same name as the class and no return type. If you write void, Java treats it as a method, not a constructor:

public class Pet
{
    private String name;

    public void Pet(String petName)
    {
        name = petName;
    }
}

Pet cat = new Pet("Miso");

Compiler says:

error: constructor Pet in class Pet cannot be applied to given types;

3. Mutable object parameters: store a copy

When a mutable object (an object whose state can change) is a constructor parameter, the instance variable should be initialized with a copy of the object. Then the instance variable does not hold a reference to the original object, and outside code cannot change the state of your object through the original 3.4.A.3.

Here is a mutable class:

public class Location
{
    private int row;
    private int col;

    public Location(int r, int c)
    {
        row = r;
        col = c;
    }

    public int getRow()
    {
        return row;
    }

    public int getCol()
    {
        return col;
    }

    public void moveTo(int r, int c)
    {
        row = r;
        col = c;
    }

    public String toString()
    {
        return "(" + row + ", " + col + ")";
    }
}

Version 1 (risky): the constructor stores the same reference.

public class Robot
{
    private Location home;

    public Robot(Location start)
    {
        home = start;
    }

    public String homeText()
    {
        return home.toString();
    }
}

Location spot = new Location(2, 3);
Robot bot = new Robot(spot);
spot.moveTo(9, 9);
System.out.println(bot.homeText());

Output:

(9, 9)

spot [ ref ] ---+
                +---> Location object: row 9, col 9
home [ ref ] ---+    (one object, two references)

Version 2 (correct): the constructor makes a new Location with the same values.

public class Robot
{
    private Location home;

    public Robot(Location start)
    {
        home = new Location(start.getRow(), start.getCol());
    }

    public String homeText()
    {
        return home.toString();
    }
}

Location spot = new Location(2, 3);
Robot bot = new Robot(spot);
spot.moveTo(9, 9);
System.out.println(bot.homeText());

Output:

(2, 3)

spot [ ref ] ---> Location object: row 9, col 9
home [ ref ] ---> Location object: row 2, col 3   (the robot's own copy)

String objects are immutable, so a constructor can store a String parameter directly: nobody can change that string.

4. The default constructor and default values

When no constructor is written, Java provides a no-parameter constructor, called the default constructor, and the instance variables are set to default values according to their data types 3.4.A.4.

Type of attribute	Default value 3.4.A.5
int	0
double	0.0
boolean	false
any reference type (such as String)	null

public class Settings
{
    private int volume;
    private double brightness;
    private boolean muted;
    private String theme;

    // no constructor written: Java provides Settings()

    public String toString()
    {
        return volume + " " + brightness + " " + muted + " " + theme;
    }
}

Settings s = new Settings();
System.out.println(s);

Output:

0 0.0 false null

Watch out: once you write any constructor, Java no longer provides the default constructor. Player has two constructors, but neither has zero parameters:

Player p = new Player();

Compiler says:

error: no suitable constructor found for Player(no arguments)

Watch out: a constructor that does not set an instance variable leaves it at its default value. A forgotten String is null, and calling a method on it later (such as name.length()) causes a NullPointerException.