Constructors

Picture two library books sitting on a cart. Both are books, built from the same blueprint, but one is Holes with 233 pages and is checked out, and the other is Wonder with 310 pages and is on the shelf. If a program is going to keep track of books, it has to remember those facts separately for each one. Where does each book keep its own facts?

Recall from Topic 1.12 that the facts a class’s objects keep track of are called attributes, and from Topic 3.3 that each attribute is stored in an instance variable: a variable declared inside the class but outside any constructor or method, so that every object gets its own copy. Here is a Book class with three attributes:

public class Book
{
    private String title;
    private int pages;
    private boolean checkedOut;
}

Each instance variable has a type and a name, like any variable from Topic 1.2, and private keeps it inside the class (Topic 3.3). The class only describes which facts a book keeps. The values themselves live in each object.

The set of values an object’s instance variables hold at a particular moment is the object’s state. “At a particular moment” matters: if Holes is returned, its checkedOut value changes from true to false, and its state is now different, even though it is the same object.

Now vary the moment instead of the object. Take a single Thermostat object whose instance variables are double temperature and boolean heating:

It is one object the whole time; its state at 7:00 differs from its state at 9:00 because the values changed. (The methods that change an object’s state after it is built are Topic 3.5. This chapter is about the very first state an object has.)

Because the instance variables belong to the object, programmers describe the connection with the words “has a”: a book has a title, has a page count, and has a checked-out status. This is called a has-a relationship between an object and its instance variables. It is a handy test when you design a class: if you can say “a _ has a _,” the second blank is a good candidate for an instance variable.

The Book class above declares three instance variables but never puts anything in them. When a program writes new Book(...), which code decides that this book is Holes with 233 pages? In Topic 1.13 you only called constructors that someone else wrote. Now you write one.

A constructor sets the initial state of a new object: the values its instance variables hold at the moment it is created. A well-written constructor gives a starting value to every instance variable, so the object never begins life half-filled-in.

Here is the shape of a constructor, written inside the class after the instance variables:

public Book(String bookTitle, int pageCount)
{
    title = bookTitle;
    pages = pageCount;
    checkedOut = false;
}

The body is where the instance variables get filled in. Inside a constructor you refer to an instance variable just by its name, title, and Java knows you mean the title of the object being built.

What actually happens when new Book("Holes", 233) runs? Three things, in order:

1. Memory is set aside for a brand-new Book object, with room for its own title, pages, and checkedOut.
2. The constructor body runs for that new object, with bookTitle holding a copy of "Holes" and pageCount a copy of 233. Its assignments fill in the instance variables.
3. A reference to the new object is handed back as the value of the whole new expression, so it can be stored in a variable.

public class BookCreation
{
    public static void main(String[] args)
    {
        System.out.println("Before the call");
        Book novel = new Book("Holes", 233);
        System.out.println("After the call");
    }
}

class Book
{
    private String title;
    private int pages;
    private boolean checkedOut;

    public Book(String bookTitle, int pageCount)
    {
        title = bookTitle;
        pages = pageCount;
        checkedOut = false;
        System.out.println(title + ", " + pages + " pages, checked out: " + checkedOut);
    }
}

Before the call
Holes, 233 pages, checked out: false
After the call

Now vary the parameter list: a constructor does not need parameters at all. Every new scoreboard starts the same way, at 0 to 0 in period 1, so its constructor takes nothing and sets fixed values. This program also builds two objects.

public class ScoreboardStart
{
    public static void main(String[] args)
    {
        Scoreboard gym = new Scoreboard();
        Scoreboard field = new Scoreboard();
        System.out.println(gym == field);
    }
}

class Scoreboard
{
    private int homeScore;
    private int awayScore;
    private int period;

    public Scoreboard()
    {
        homeScore = 0;
        awayScore = 0;
        period = 1;
        System.out.println("Home " + homeScore + ", Away " + awayScore + ", Period " + period);
    }
}

Home 0, Away 0, Period 1
Home 0, Away 0, Period 1
false

Each new on lines 5 and 6 sets aside memory for a separate Scoreboard, runs the constructor for it, and returns a different reference. The two objects happen to have identical states, but they are two objects. Line 7 compares the references with == (Topic 2.6), and false confirms they are not aliases: changing the gym’s score later would never change the field’s.

public class BookVoid
{
    public static void main(String[] args)
    {
        Book novel = new Book("Holes", 233);
    }
}

class Book
{
    private String title;
    private int pages;

    public void Book(String bookTitle, int pageCount)
    {
        title = bookTitle;
        pages = pageCount;
    }
}

BookVoid.java:5: error: constructor Book in class Book cannot be applied to given types;
  required: no arguments
  found:    String,int

public class StudentTrace
{
    public static void main(String[] args)
    {
        System.out.println("Start");
        Student first = new Student("Mia", 11);
        Student second = new Student("Leo", 9);
        System.out.println("End");
    }
}

class Student
{
    private String name;
    private int grade;

    public Student(String studentName, int gradeLevel)
    {
        name = studentName;
        grade = gradeLevel;
        System.out.println(name + " is in grade " + grade);
    }
}

Start
Mia is in grade 11
Leo is in grade 9
End

A constructor with no parameters builds identical objects, which is right for a scoreboard but wrong for pets: every pet has a different name and age. How does the code that writes new Pet(...) tell the constructor which pet to build?

Through parameters, exactly as in Topic 1.13: the caller passes arguments, and each parameter starts with a copy of its argument. The constructor’s job is to move that data into the instance variables. A parameter is a temporary variable that disappears when the constructor ends; an instance variable lasts as long as the object. If the constructor does not copy a parameter’s value into an instance variable, the value is lost.

There is a naming rule to follow for now: give each parameter a different name from the instance variable it fills, such as petName for name. You will see why in the Watch Out below.

public class PetCreation
{
    public static void main(String[] args)
    {
        Pet dog = new Pet("Biscuit", 3);
        Pet cat = new Pet("Pepper", 7);
    }
}

class Pet
{
    private String name;
    private int age;
    private int vetVisits;

    public Pet(String petName, int petAge)
    {
        name = petName;
        age = petAge;
        vetVisits = 0;
        System.out.println(name + ", age " + age + ", vet visits: " + vetVisits);
    }
}

Biscuit, age 3, vet visits: 0
Pepper, age 7, vet visits: 0

Now vary what the body does with a parameter. The body is ordinary code, so it can compute a starting value from the parameters, including with a Boolean expression (Topic 2.2) and an if statement (Topic 2.3). A concert ticket in rows 1 through 3 is a VIP ticket costing $80; any other row costs $45.

public class ConcertTicketPrice
{
    public static void main(String[] args)
    {
        ConcertTicket front = new ConcertTicket("The Comets", 2);
        ConcertTicket back = new ConcertTicket("The Comets", 15);
    }
}

class ConcertTicket
{
    private String band;
    private int row;
    private boolean vip;
    private double price;

    public ConcertTicket(String bandName, int seatRow)
    {
        band = bandName;
        row = seatRow;
        vip = seatRow <= 3;
        if (vip)
        {
            price = 80.0;
        }
        else
        {
            price = 45.0;
        }
        System.out.println(band + " row " + row + ": VIP " + vip + ", $" + price);
    }
}

For the first ticket, seatRow is 2, so line 21 sets vip to 2 <= 3, which is true, and the if sets price to 80.0. For the second, seatRow is 15, vip is false, and the else sets price to 45.0.

The Comets row 2: VIP true, $80.0
The Comets row 15: VIP false, $45.0

The caller passed only a band and a row, yet all four instance variables got starting values: two copied from parameters and two computed from them.

public class PetSameName
{
    public static void main(String[] args)
    {
        Pet dog = new Pet("Biscuit", 3);
        System.out.println("A Pet was created.");
    }
}

class Pet
{
    private String name;
    private int age;

    public Pet(String name, int age)
    {
        name = name;
        age = age;
    }
}

public class GymPassTrace
{
    public static void main(String[] args)
    {
        GymPass first = new GymPass("Ines", 3, 17);
        GymPass second = new GymPass("Omar", 2, 25);
    }
}

class GymPass
{
    private String member;
    private int months;
    private boolean student;
    private double cost;

    public GymPass(String memberName, int monthCount, int age)
    {
        member = memberName;
        months = monthCount;
        student = age < 19;
        cost = monthCount * 30.0;
        if (student)
        {
            cost = cost / 2;
        }
        System.out.println(member + ": " + months + " months, $" + cost + ", student " + student);
    }
}

Ines: 3 months, $45.0, student true
Omar: 2 months, $60.0, student false

The Watch Out above said an instance variable that was never assigned is “still null” or “still 0.” But nobody wrote null or 0 anywhere. Where do those values come from? And what happens if a class has no constructor at all?

Remember step 1 of a constructor call from 3.4.2: memory is set aside for the new object. Java never leaves that memory holding leftover junk. Before any constructor code runs, every instance variable is given a default value that depends only on its type:

Each is the “nothing yet” value for its type: zero for numbers, false for a true/false fact, and null, meaning “no object” (Topic 1.13), for references. Your constructor’s assignments then replace these defaults. Any instance variable the constructor skips keeps its default.

public class PlayerForgot
{
    public static void main(String[] args)
    {
        Player rookie = new Player("Jordan");
    }
}

class Player
{
    private String name;
    private String team;
    private int goals;
    private double average;
    private boolean injured;

    public Player(String playerName)
    {
        name = playerName;
        System.out.println("name: " + name);
        System.out.println("team: " + team);
        System.out.println("goals: " + goals);
        System.out.println("average: " + average);
        System.out.println("injured: " + injured);
    }
}

name: Jordan
team: null
goals: 0
average: 0.0
injured: false

Now vary the class: remove the constructor entirely.

public class DefaultLamp
{
    public static void main(String[] args)
    {
        Lamp desk = new Lamp();
        System.out.println("A Lamp was created.");
    }
}

class Lamp
{
    private String color;
    private int brightness;
    private double watts;
    private boolean on;
}

A Lamp was created.

Lamp has no constructor, yet line 5 calls new Lamp() and it works. When a class has no constructor written at all, Java supplies one: a constructor with no parameters and an empty body. It is called the default constructor. Since its body does nothing, the new lamp’s instance variables keep their defaults: color is null, brightness is 0, watts is 0.0, and on is false.

public class NoDefaultAnymore
{
    public static void main(String[] args)
    {
        Lamp desk = new Lamp();
    }
}

class Lamp
{
    private String color;
    private int brightness;

    public Lamp(String lampColor, int level)
    {
        color = lampColor;
        brightness = level;
    }
}

NoDefaultAnymore.java:5: error: constructor Lamp in class Lamp cannot be applied to given types;
  required: String,int
  found:    no arguments
  reason: actual and formal argument lists differ in length

public class SensorDefaults
{
    public static void main(String[] args)
    {
        Sensor porch = new Sensor("porch", 21.5);
    }
}

class Sensor
{
    private String location;
    private double temperature;
    private int readings;
    private boolean alarm;
    private String unit;

    public Sensor(String place, double startTemp)
    {
        location = place;
        readings = readings + 1;
        System.out.println(location + " " + temperature + " " + readings);
        System.out.println(alarm + " " + unit);
    }
}

porch 0.0 1
false null

public class BookReversed
{
    public static void main(String[] args)
    {
        Book story = new Book("Holes", 233);
    }
}

class Book
{
    private String title;
    private int pages;

    public Book(String bookTitle, int pageCount)
    {
        title = bookTitle;
        pageCount = pages;
        System.out.println(title + " has " + pages + " pages");
    }
}

pages = pageCount;

So far every parameter has been a primitive or a String. What if a constructor receives an object that can change? Call by value copies the argument, but for a reference type the argument is a reference, so the constructor gets a copy of the address, not a copy of the object.

An object whose state can change after it is built is called mutable. You already know one. In Topic 2.6 you saw that a Scanner moves forward through its input each time you read from it, so reading changes its state. A String is not mutable: once built, its characters never change (Topic 1.15). Storing a reference to a String is always safe, because nobody can change the object behind your back.

import java.util.Scanner;

public class GraderShared
{
    public static void main(String[] args)
    {
        Scanner key = new Scanner("B D A C");
        Grader quizOne = new Grader(key);
        System.out.println("main reads: " + key.next());
    }
}

class Grader
{
    private Scanner answers;
    private String firstAnswer;

    public Grader(Scanner answerKey)
    {
        answers = answerKey;
        firstAnswer = answers.next();
        System.out.println("Grader reads: " + firstAnswer);
    }
}

Grader reads: B
main reads: D

This is why, when a constructor receives a mutable object, the instance variable should hold a copy of that object: a new object with the same values. Then the instance variable does not refer to the caller’s object, so code in the class cannot change the caller’s object, and changes the caller makes cannot reach inside the new object.

A Scanner cannot be copied, but a class can offer a way to copy its own objects. Below, Address is mutable: its moveTo method changes the street. (Lines 27–30 are a method; you will learn to write methods in Topic 3.5. You only need to know that calling moveTo changes an Address object’s street.) Address also has a second constructor, on lines 21–25, that builds a new Address holding the same street and city as one it is given. It can read original.street because private limits access to code written inside the Address class (Topic 3.3), and this constructor is inside it.

public class OrderCopy
{
    public static void main(String[] args)
    {
        Address home = new Address("12 Oak St", "Akron");
        Order lamp = new Order("lamp", home);
    }
}

class Address
{
    private String street;
    private String city;

    public Address(String streetName, String cityName)
    {
        street = streetName;
        city = cityName;
    }

    public Address(Address original)
    {
        street = original.street;
        city = original.city;
    }

    public void moveTo(String newStreet)
    {
        street = newStreet;
    }
}

class Order
{
    private String item;
    private Address shipTo;

    public Order(String itemName, Address destination)
    {
        item = itemName;
        shipTo = new Address(destination);
        System.out.println("Same Address object as the caller's? " + (shipTo == destination));
    }
}

Same Address object as the caller's? false

Line 41 calls new Address(destination), so shipTo gets a reference to a new object with the same values. Line 42 compares references with == and confirms that shipTo and the caller’s home are different objects. If the order had instead stored the reference directly, shipTo = destination;, the same program prints Same Address object as the caller's? true:

A hotel program records each stay. A stay has a guest, a number of nights, a total cost, a paid status, and a billing address. Guests booking just one night can leave out the number of nights. Read the whole file, then follow the trace.

public class Booking
{
    public static void main(String[] args)
    {
        Address ana = new Address("12 Oak St", "Akron");
        System.out.println("Booking rooms...");
        HotelStay longStay = new HotelStay("Ana", 3, ana);
        HotelStay quickStay = new HotelStay("Ana", ana);
        System.out.println("Done");
    }
}

class Address
{
    private String street;
    private String city;

    public Address(String streetName, String cityName)
    {
        street = streetName;
        city = cityName;
    }

    public Address(Address original)
    {
        street = original.street;
        city = original.city;
    }

    public void moveTo(String newStreet)
    {
        street = newStreet;
    }
}

class HotelStay
{
    private String guest;
    private int nights;
    private double total;
    private boolean paid;
    private Address billing;

    public HotelStay(String guestName, int stayNights, Address guestAddress)
    {
        guest = guestName;
        nights = stayNights;
        total = stayNights * 89.5;
        paid = false;
        billing = new Address(guestAddress);
        System.out.println(guest + ": " + nights + " nights, $" + total + ", paid " + paid);
    }

    public HotelStay(String guestName, Address guestAddress)
    {
        guest = guestName;
        nights = 1;
        total = 89.5;
        paid = false;
        billing = new Address(guestAddress);
        System.out.println(guest + ": " + nights + " night, $" + total + ", paid " + paid);
    }
}

Booking rooms...
Ana: 3 nights, $268.5, paid false
Ana: 1 night, $89.5, paid false
Done

Check the habits from this chapter against the code. Both constructors set all five instance variables, including paid = false, which matches the default but is written on purpose. Every parameter name differs from its instance variable. And because Address is mutable, each stay keeps its own copy: if Ana later moves and main calls ana.moveTo(...), the addresses on the existing stays do not change. Five objects exist at the end, one for each new that ran (lines 5, 7, 50, 8, and 60): ana’s Address, two HotelStay objects, and two Address copies.

• An object’s state is the values of its instance variables at a given moment. The instance variables belong to the object, giving a has-a relationship, and each object has its own copy.
• A constructor has the class name, is public, and has no return type. Calling it with new sets aside memory for the object, runs the body, and returns a reference to the new object.
• A constructor should give every instance variable a starting value. Values can come from parameters (named differently from the instance variables), be fixed, or be computed from parameters.
• Instance variables start at their default values (0, 0.0, false, null). If a class has no constructor, Java supplies a no-parameter default constructor that leaves them that way; writing any constructor removes it.
• When a constructor receives a mutable object, the instance variable should hold a copy made with new, so the object and the caller never share it.

public class CampSignup
{
    public static void main(String[] args)
    {
        Camper first = new Camper("Rosa", 12);
        Camper second = new Camper("Eli", 8);
        Camper third = new Camper("Kai");
    }
}

class Camper
{
    private String name;
    private int age;
    private boolean swimmer;
    private double fee;

    public Camper(String camperName, int camperAge)
    {
        name = camperName;
        age = camperAge;
        swimmer = camperAge >= 10;
        fee = 150.0;
        System.out.println(name + " " + age + " " + swimmer + " " + fee);
    }

    public Camper(String camperName)
    {
        name = camperName;
        System.out.println(name + " " + age + " " + swimmer + " " + fee);
    }
}

Rosa 12 true 150.0
Eli 8 false 150.0
Kai 0 false 0.0

public class LockerNoArgs
{
    public static void main(String[] args)
    {
        Locker gymLocker = new Locker();
    }
}

class Locker
{
    private int number;
    private String lockColor;

    public Locker(int lockerNumber, String color)
    {
        number = lockerNumber;
        lockColor = color;
        System.out.println("Locker " + number + " has a " + lockColor + " lock");
    }
}

Locker gymLocker = new Locker(214, "blue");

import java.util.Scanner;

public class GraderTwice
{
    public static void main(String[] args)
    {
        Scanner key = new Scanner("A C B D");
        Grader quizOne = new Grader(key);
        Grader quizTwo = new Grader(key);
        System.out.println("main reads: " + key.next());
    }
}

class Grader
{
    private Scanner answers;
    private String firstAnswer;

    public Grader(Scanner answerKey)
    {
        answers = answerKey;
        firstAnswer = answers.next();
        System.out.println("Grader reads: " + firstAnswer);
    }
}

Grader reads: A
Grader reads: C
main reads: B

• I can describe an object’s state and the has-a relationship between an object and its instance variables. Reread
• I can write a constructor header with no return type and explain what happens in memory when it is called. Reread
• I can use parameters with different names to give every instance variable a starting value. Reread
• I can state the default values for int, double, boolean, and reference types, and say when Java supplies a default constructor. Reread
• I can explain why a constructor should copy a mutable object it receives. Reread