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;

Practice: Simple Object Field

Created By: CS 124 Staff
/ Version: 2020.9.0

Create a class called Simple that stores a single int value using a field named value. Simple should implement a function called setValue that accepts a single int and changes the saved value. (It should not return a value.) Simple should also implement a function called getValue that returns the saved value.

Note that you should include public before your class definition for this problem. We've provided starter code that does that. If that doesn't fully make sense yet, don't worry. It will soon.

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);

Practice: Simple Object Field 2

Created By: CS 124 Staff
/ Version: 2021.9.0

Create a class called Simple that stores a single String value using a field named data. Simple should implement a function called setData that accepts a single String and changes the saved value. (It should not return a value.) Simple should also implement a function called getData that returns the saved value.

Note that you should include public before your class definition for this problem. We've provided starter code that does that. If that doesn't fully make sense yet, don't worry. It will soon.

Homework: Simple Object Fields 3

Created By: CS 124 Staff
/ Version: 2022.9.0

Create a class called Location that stores two int values representing the location of a place on the surface of the Earth. Location should implement a function called setX that accepts a single int and changes the saved x value. (It should not return a value.) Simple should also implement a function called getX that returns the saved x value. Complete the analogous methods for y.

Note that you should include public before your class definition for this problem. We've provided starter code that does that. If that doesn't fully make sense yet, don't worry. It will soon.

More Practice

Need more practice? Head over to the practice page.