KotlinCS 124 LogoJava

Constructors

public class Dimensions {
double width;
double height;
Dimensions(double setWidth, double setHeight) {
width = setWidth;
height = setHeight;
}
double area() {
return width * height;
}
}
Dimensions room = new Dimensions(8.8, 10.0);
System.out.println(room.area());

Let’s continue our discussion of Java objects. Remember that bit of syntax that looked like a method call when we create a new Java object? Well, it was! Next we’ll talk about what it does.

Constructors
Constructors

Previously when we created instances of our new object classes, we used new followed by something that looked like a method call to a function accepting no parameters:

class Person {
String name;
double age;
}
Person geoff = new Person();
geoff.name = "Geoff";
geoff.age = 41.05;

It turns out that this is exactly what follows new. Usually when we create a new object we want to set the fields on it right away. Rather than doing this in the fairly clumsy way shown above, Java provides a better alternative. Let’s look at it together!

class Person {
String name;
double age;
}
Person geoff = new Person();
geoff.name = "Geoff";
geoff.age = 41.05;

Constructor Semantics
Constructor Semantics

There are a few things to keep in mind about constructors.

First, they must have the same name as the class and cannot declare a return value:

class Person {
String name;
double age;
// Only three parts to this method declaration
Person(String setName, double setAge) {
name = setName;
age = setAge;
}
}
Person you = new Person("Great Student", 18);
System.out.println(you.name + " is " + you.age);

You can, however, use return in a constructor if you want to skip some parts of the initialization in certain cases:

class Person {
String name;
double age;
// Only three parts to this method declaration
Person(String setName, double setAge) {
if (setAge < 0.0) {
// Don't set name on people with negative age...
return;
}
name = setName;
age = setAge;
}
}
Person unborn = new Person("New Baby", -0.2);
System.out.println(unborn.name);

Finally, we don’t need to declare a constructor. If we don’t, Java will include a default constructor that takes no arguments. Let’s see how that works:

class Person {
String name;
double age;
}
Person geoff = new Person();
geoff.name = "Geoff";
geoff.age = 41.05;

Overloaded Constructors
Overloaded Constructors

Just like with other methods, classes can provide multiple constructors as long as they accept different parameters:

class Person {
String name;
double age;
Person(String setName, double setAge) {
name = setName;
age = setAge;
}
// Useful for really new people, like babies
Person(String setName) {
name = setName;
age = 0.0;
}
}
Person geoff = new Person("Geoff", 41.05);
// Lily is my niece. Super cute. Probably not into Java yet.
Person lily = new Person("Lily");
System.out.println(geoff.age);
System.out.println(lily.age);

More Practice

Need more practice? Head over to the practice page.