Lesson 13Phase 2: Objects

Constructors

Building objects in a valid state from the first moment, default vs custom constructors, and overloading them.

By BasithUpdated 26 October 202655 min

constructor
default constructor
constructor overloading
new flow
this()
initialization

You can build an object and you can give it behavior. But every object so far has started out empty and been filled in by hand, one field at a time, and nothing reminds you if you skip one. This lesson is about the part of Java that fixes that: a constructor, a piece of setup code that runs while the object is being created, so the object is complete before your code ever gets hold of it.

By the end of this lesson

Say what a constructor is and when it runs.
Write a constructor that takes values in and stores them in the object's fields.
Explain this.name = name: which name is which, and why the this. is needed.
Describe what new does, step by step, including where a field's starting value comes from.
Predict when the free no-argument constructor exists and when it disappears.
Write several constructors for one class and chain them together with this(...).

From before

You already write classes with fields and make objects with new (creating classes and objects), and you give them methods that take parameters and return values. A constructor looks a lot like a method, so keep parameters fresh in mind. You also saw that a method runs on one particular object, the one before the dot. This lesson gives that object a name in your code: this. Inheritance comes later, so every example here has a single class.

The problem: an object born half-finished#

Here is a Student class with three fields. We make one student and set it up by hand, the only way we know so far.

Student.java

1public class Main {

2 public static void main(String[] args) {

3 Student s = new Student();

4 s.name = "Mara";

5 s.age = 19;

7 System.out.println(s.name + ", age " + s.age + ", gpa " + s.gpa);

8 }

9}

11class Student {

12 String name;

13 int age;

14 double gpa;

15}

Prints

›Mara, age 19, gpa 0.0

It prints Mara, age 19, gpa 0.0. The gpa is 0.0 because we forgot to set it, and Java did not stop us. As you saw when you first made objects, every field of a new object starts at a default value: 0 for an int, 0.0 for a double, false for a boolean, and null for an object type such as String. The object exists, but it is half-finished, and nothing told us.

The defaults apply to fields, the variables that live inside an object. A local variable, one declared inside a method, gets no default at all. If you read it before giving it a value, the program does not compile: int count; System.out.println(count); stops javac with variable count might not have been initialized.

Fields go the other way, and Java sets every one to a known zero, so a field always holds something. That guarantee has a cost. A field at its default looks exactly like a field you meant to set. A gpa of 0.0 might belong to a student who failed every course, or to a student whose gpa nobody filled in. The object cannot tell you which.

Now scale this up. Three fields are easy to remember. A real Student might have a name, an age, a gpa, a student number, an email and a major. Every time anyone, anywhere in the program, makes a student, they must remember to set all six, with the right types, and never miss one. The first time someone forgets, a broken student travels through your program looking completely normal.

Key idea
Setting fields one by one after new depends on every programmer remembering every field, every time, and Java never checks that they did.

A constructor: setup that runs during new#

The fix is to attach the setup to the class itself, so it cannot be skipped. That piece of setup is called a constructor. It is a special block of code that Java runs automatically as part of new, before the new object is handed back to you. Here is the same Student, now with a constructor.

Student.java

1public class Main {

3 public static void main(String[] args) {

4 Student s = new Student("Mara", 19);

5 System.out.println(s.name + " is " + s.age);

6 }

7}

9class Student {

10 String name;

11 int age;

13 Student(String name, int age) {

14 this.name = name;

15 this.age = age;

16 }

17}

Prints

›Mara is 19

Press Run and step through, keeping an eye on the memory view. The first step creates the Student object, with name still null and age still 0. The next step starts the constructor with the arguments "Mara" and 19. Then come two steps that set this object's name field to "Mara" and its age field to 19, and only after that is s declared and pointed at the finished object. There was never a moment when s pointed at a student without a name. The program prints Mara is 19.

What makes it a constructor and not a method

A constructor looks almost like a method, with two deliberate differences. Spot them in the code above.

Its name is exactly the class name. The constructor for Student is named Student, with the same capital letter. This is how Java recognizes it.
It has no return type, not even void. A method such as void greet() has a return type in front of its name; a constructor has nothing there. It does not hand a value back. It sets up the object.

A method

A constructor

Has any name you like, such as greet.

Must be named exactly after the class, Student.

Has a return type: void, int, String.

Has no return type at all, not even void.

You call it yourself, whenever you want.

Java calls it for you, during new.

Runs on an object that already exists.

Runs while the object is being built, to set it up.

Can be called many times on the same object.

Runs once for each object, when that object is created.

It is a fair thought, because new Student("Mara", 19) does give you an object. But the constructor is not what hands the object back; newdoes that. The constructor's job is to set up the object that new has already made, so Java forbids a return type.

If you write one by accident, as in void Student(String name, int age), Java reads it as an ordinary method that happens to share the class name, and it never runs during new. Your class is then left with only the free constructor that takes no arguments (you will see where that one comes from further down), so new Student("Mara", 19) stops compiling. The error says the constructor needs no arguments, which is baffling until you spot the stray void.

Quick check

Which of these is a constructor for a class named Lamp?

Coming from Python or JavaScript?

A constructor does the job of Python's __init__ or the constructor method of a JavaScript class. In Java the constructor is named after the class, the fields are declared in the class body rather than created by assignment, and there is no self parameter to write. The object being built is always available as this, which the next section explains.

this.name = name: reading the most confusing line#

The line this.name = name stops a lot of beginners, because the word name appears twice and both look the same. They are two different things that happen to share a name.

Inside that constructor, one name is the parameter, the value "Mara" that was just passed in. The other is the field, the slot inside the object where the student's name is meant to live. When two things in the same place share a name, the closer one wins. The parameter is closer, so a bare name means the parameter. The field is hidden, or shadowed, by it.

Key idea
this.name means “the name field of this object”. Plain namemeans “the parameter that was passed in”. So this.name = namereads: take the value that was passed in, and store it in this object's own field.

The word this is how an object refers to itself from the inside. While the constructor runs for the student being created, this points at exactly that student. So this.name reaches into that one object and names its name field, the same way s.name reaches in from the outside.

Could we just rename the parameter?

Yes, and people do. If you called the parameter n instead of name, there would be no clash, and name = n would already mean the field. But naming the parameter after the field it fills is so common, and reads so clearly, that the this.field = field pattern is everywhere in real Java. Learning to read it now saves you confusion in every codebase you open.

The flow of new, in three steps#

With a constructor in the picture, it is worth being exact about what new Student("Mara", 19) does, in order. It is always the same three steps.

1Java makes the object. It sets aside memory for one new Student and gives every field its default: name is null, age is 0. The object exists now, but it is blank.
2Java runs the matching constructor on that blank object, passing your arguments in. This is where this.name = name and this.age = age run and turn the blank object into a real student.
3Only now does new finish and hand you a reference to the finished object, which the assignment stores in s.

You can watch this order for yourself by printing from inside the constructor. The line printed between the two outer prints can only have come from step 2, in the middle of new.

Student.java

1public class Main {

3 public static void main(String[] args) {

4 System.out.println("before new");

5 Student s = new Student("Mara", 19);

6 System.out.println("after new: " + s.name);

7 }

8}

10class Student {

11 String name;

12 int age;

14 Student(String name, int age) {

15 System.out.println("constructor running");

16 this.name = name;

17 this.age = age;

18 }

19}

Prints

›before new

›constructor running

›after new: Mara

The output is before new, then constructor running, then after new: Mara. The middle line shows the constructor ran during new, before s was ready. By the time you hold s, the setup is done.

Put the lines in orderTicket.java

Put the lines in order so the program prints before new, then constructor running for Dune, then after new: Dune.

Tap a line, then tap where it should go. Or use the arrows.

Fields with a starting value#

A field can also get its starting value right where it is declared. In a game, every new player starts with three lives, so the class can say that once: int lives = 3;. This is called a field initializer. Java stores those values during step 2, just before the constructor's own lines run, so the constructor already sees them.

Player.java

1public class Main {

2 public static void main(String[] args) {

3 Player p = new Player("Ada");

4 System.out.println(p.name + " has " + p.lives + " lives and " + p.score + " points");

5 }

6}

8class Player {

9 String name;

10 int lives = 3;

11 int score;

13 Player(String name) {

14 System.out.println("constructor sees lives = " + lives);

15 this.name = name;

16 }

17}

Prints

›constructor sees lives = 3

›Ada has 3 lives and 0 points

Step through it and watch lives in the memory view. It is 0 when the object appears, like any new field, and 3 by the time the constructor's first line prints. The output is constructor sees lives = 3 and then Ada has 3 lives and 0 points. score has no initializer, so it keeps its default of 0.

Initializer or constructor?

Use a field initializer for a starting value that is the same for every object, such as three lives. Use the constructor for values that differ from one object to the next, such as the player's name.

The free constructor that disappears#

Go back to the very first example. It had no constructor at all, yet new Student() worked. When you write a class with no constructor, Java quietly gives it one: an empty no-argument constructor that takes nothing and does nothing beyond the defaults. It is called the default constructor, and it is why new Student() compiled in the first example.

Here is the rule that surprises people. The moment you write any constructor of your own, the free one is gone. Java only supplies it when you have written none. So once Student has Student(String name, int age), the empty new Student() no longer exists, and using it is a compile error:

Main.java (does not compile)

read along

1public class Main {

2 public static void main(String[] args) {

3 Student s = new Student(); // no longer allowed

4 System.out.println(s.name);

5 }

6}

8class Student {

9 String name;

10 int age;

12 // Once this exists, the free no-argument constructor is gone.

13 Student(String name, int age) {

14 this.name = name;

15 this.age = age;

16 }

17}

Output

Main.java:3: error: constructor Student in class Student cannot be applied to given types;
        Student s = new Student();   // no longer allowed
                    ^
  required: String,int
  found:    no arguments
  reason: actual and formal argument lists differ in length
1 error

Read the message from the top. Main.java:3 points at the call on line 3. required: String,int lists what the class's only constructor takes, and found: no arguments is what the call passed.

Writing one constructor removes the free one

This trips up almost everyone once. You add a constructor with parameters, and old code that said new Student() stops compiling. Nothing was deleted; the free no-argument constructor only existed because you had written none. If you still want new Student() to work, write the no-argument constructor yourself, next to the others.

It protects you. Once you have decided a Student needs a name and an age to be valid, an empty new Student() would produce exactly the half-finished object you wrote a constructor to prevent. By removing the free version, Java makes sure nobody can quietly skip your setup. If you really do want a blank student to be allowed, you write that constructor yourself, and then it is a decision rather than an accident.

Quick check

Which of these classes does not allow new Point()?

Many constructors for one class#

Sometimes there is more than one sensible way to make an object. You might know everything about a new student, or only their name, with the rest taking sensible starting values. Java lets you write several constructors for the same class, as long as their parameter lists differ. This is constructor overloading, the same idea as overloading a method, applied to the class name.

Student.java

1public class Main {

3 public static void main(String[] args) {

4 Student a = new Student("Mara", 19, 3.8);

5 Student b = new Student("Tom", 20);

6 Student c = new Student("Lin");

8 System.out.println(a.name + " " + a.age + " gpa " + a.gpa);

9 System.out.println(b.name + " " + b.age + " gpa " + b.gpa);

10 System.out.println(c.name + " " + c.age + " gpa " + c.gpa);

11 }

12}

14class Student {

15 String name;

16 int age;

17 double gpa;

19 Student(String name, int age, double gpa) {

20 this.name = name;

21 this.age = age;

22 this.gpa = gpa;

23 }

25 Student(String name, int age) {

26 this.name = name;

27 this.age = age;

28 this.gpa = 0.0;

29 }

31 Student(String name) {

32 this.name = name;

33 this.age = 18;

34 this.gpa = 0.0;

35 }

36}

Prints

›Mara 19 gpa 3.8

›Tom 20 gpa 0.0

›Lin 18 gpa 0.0

Three constructors, all named Student, told apart by how many values they take. When you write new Student("Tom", 20), Java looks for the constructor that fits two arguments and runs that one. The output is Mara 19 gpa 3.8, then Tom 20 gpa 0.0, then Lin 18 gpa 0.0. Each student is fully set up, even the ones given less information, because each constructor fills in its own sensible defaults.

How Java picks which one to run

It matches on the arguments you give: how many there are, and their types. new Student("Lin") passes one String, so the one-parameter constructor runs. If no constructor matches the arguments you wrote, the program does not compile. The set of constructors is the menu of allowed ways to make a Student.

Repeating yourself, and a cleaner way to write it

Look closely at those three constructors. The first sets all three fields. The second copies two of those lines and adds a default for gpa. The third copies one line and adds defaults for the other two. The setup is written out three times, and if you ever add a fourth field, you must remember to update all three constructors. That is the forgetting problem we started with, moved inside the class.

Java has a fix: one constructor can hand the job to another with this(...). Read this(name, 18, 0.0)as “run the constructor of this same class that matches these arguments”. The full setup lives in one place, and the shorter constructors call it with their defaults filled in.

Student.java

1public class Main {

2 public static void main(String[] args) {

3 Student a = new Student("Mara", 19, 3.8);

4 Student b = new Student("Tom", 20);

5 Student c = new Student("Lin");

7 System.out.println(a.name + " " + a.age + " gpa " + a.gpa);

8 System.out.println(b.name + " " + b.age + " gpa " + b.gpa);

9 System.out.println(c.name + " " + c.age + " gpa " + c.gpa);

10 }

11}

13class Student {

14 String name;

15 int age;

16 double gpa;

18 // The one real constructor: it sets everything.

19 Student(String name, int age, double gpa) {

20 this.name = name;

21 this.age = age;

22 this.gpa = gpa;

23 }

25 // Hands over to the full one, supplying a default gpa.

26 Student(String name, int age) {

27 this(name, age, 0.0);

28 }

30 // Hands over again, supplying a default age and gpa.

31 Student(String name) {

32 this(name, 18, 0.0);

33 }

34}

Prints

›Mara 19 gpa 3.8

›Tom 20 gpa 0.0

›Lin 18 gpa 0.0

The output is the same three lines as before. Step through new Student("Lin") and read the narration: Java first runs the constructor with "Lin", and that one immediately runs the constructor with "Lin", 18, 0.0. The steps that set the three fields all come from that full constructor. One new, two constructors, and the fields are assigned in one place only.

A constructor may call this(...) at most once, and only as a statement of its own, never inside an if or a loop. Constructors may not call each other in a circle either: if Student(String name) called this(name, 18) and Student(String name, int age) called this(name) back, they would hand the job to each other forever, so javac refuses with recursive constructor invocation.

Until Java 25, this(...)also had to be the very first line of the constructor. Since Java 25 a few lines may come before it, as long as they do not use the object being built: they may check or tidy the arguments, but they may not read the object's fields or call its methods. This page keeps this(...) on the first line, which is how most Java code you will read is written.

Key idea
Write the real setup once, in the constructor with the most parameters, and let the shorter constructors hand over to it with this(...), filling in defaults. Then a new field means one change in one place.

Each constructor in a chain can do some work of its own after the hand-over. That raises a question about order. Decide before you run this one.

Predict the outputCoffee.java

1public class Main {

2 public static void main(String[] args) {

3 Coffee order = new Coffee();

4 System.out.println(order.size + ", " + order.sugars + " sugars");

5 }

6}

8class Coffee {

9 String size;

10 int sugars;

12 Coffee(String size, int sugars) {

13 System.out.println("full constructor");

14 this.size = size;

15 this.sugars = sugars;

16 }

18 Coffee(String size) {

19 this(size, 0);

20 System.out.println("size-only constructor");

21 }

23 Coffee() {

24 this("medium");

25 System.out.println("no-argument constructor");

26 }

27}

new Coffee() sets off a chain of three constructors, and each one prints a line. What does the program print?

full constructor size-only constructor no-argument constructor medium, 0 sugarsno-argument constructor size-only constructor full constructor medium, 0 sugarsno-argument constructor medium, 0 sugarsfull constructor medium, 0 sugars

All three constructors print, and the full constructor prints first. new Coffee() does start in Coffee(), but its first line, this("medium"), hands over before anything is printed. That constructor hands over again with this(size, 0). So the full constructor is the first to reach a println, and each of the others prints only after the constructor it called has finished, just as a method call finishes before the line after it runs.

ExerciseBook.java

Finish the two Book constructors. The first stores all three values in the fields. The second takes only a title and a page count, and hands over to the first with this(...), passing true for inStock.

1public class Main {
2    public static void main(String[] args) {
3        Book a = new Book("Dune", 412, false);
4        Book b = new Book("Emma", 474);
5 
6        System.out.println(a.title + ", " + a.pages + " pages, in stock: " + a.inStock);
7        System.out.println(b.title + ", " + b.pages + " pages, in stock: " + b.inStock);
8    }
9}
10 
11class Book {
12    String title;
13    int pages;
14    boolean inStock;
15 
16    Book(String title, int pages, boolean inStock) {
17        // TODO: store all three values in the fields
18    }
19 
20    Book(String title, int pages) {
21        // TODO: hand over to the constructor above, with inStock set to true
22    }
23}

Where this is heading

A constructor makes sure an object starts out complete. It does not yet stop someone writing s.gpa = -5.0 a moment later and spoiling it. Making sure an object can only ever hold sensible values is the job of encapsulation, the next lesson. The keyword this has more to it as well, including how two variables can point at the same object; that is the this keyword and object references. And once classes build on other classes in inheritance, constructors gain one more move, super(...).

Try it

Answer each one in your head or on paper first, then open the answer.

Name the two things that make a block of code a constructor rather than an ordinary method.

In the line this.age = age inside a constructor, what does each age refer to, and which value ends up stored where?

Open in playground

A class has no constructors written at all. Is new Thing() allowed? Now you add Thing(int x) and write nothing else. Is new Thing() still allowed?

Look at the three-constructor Student. Which constructor runs for new Student("Lin"), and what are age and gpa afterwards?

Open in playground

What is the difference between a constructor that hands over with this(name, 18, 0.0) and one that writes the three assignments itself? Does the finished object differ?

A class declares int lives = 3; and its constructor ends with lives = 5;. How many lives does a new object have, and why?

Practice

Work through these on your own. Each one builds on this page.

Write a Pet class with fields name (String), species (String) and vaccinated (boolean). Give it one constructor that takes all three and stores them with the this.field = field pattern. In main, make two different pets and print all three fields of each.

Add a second constructor to Pet that takes only name and species and hands over to the first with this(...), setting vaccinated to false. Make a pet with each constructor and confirm both come out fully set up. Then try new Pet() with no arguments and explain in one sentence why it does not compile.

Break a constructor on purpose: inside it, write name = name instead of this.name = name. Predict what the name field holds after construction, then run it and see. Write one sentence explaining the result.

Write a Timer class with fields minutes and seconds and three constructors: Timer(int minutes, int seconds), Timer(int minutes) with 0 seconds, and Timer() for a one-minute timer. Chain them with this(...) so the fields are assigned in one constructor only. Put a println at the end of each constructor, and write down the order of the printed lines for new Timer() before you run it.

Short guides on this topic

Quick answers to what people search for about it, with code to run.

this vs super in Java, with Examplesthis means the current object and super means the part it inherits from its parent. this.field, this(), super.method() and super() side by side, with the rules.8 min

Spotted a mistake, or a part that did not make sense? Report it by email

Constructors

The problem: an object born half-finished#

A constructor: setup that runs during new#

What makes it a constructor and not a method

this.name = name: reading the most confusing line#

The flow of new, in three steps#

Fields with a starting value#

The free constructor that disappears#

Many constructors for one class#

Repeating yourself, and a cleaner way to write it

Try it

Practice

Further reading#

Short guides on this topic