Constructors

Primary and secondary constructors, init blocks, defining properties as constructor arguments

— — — — — — — — — — — — — — —

THE CURRENT VERSION OF THIS ARTICLE IS PUBLISHED HERE.

— — — — — — — — — — — — — — —

Tags: #KOTLIN FEATURE #EXERCISE

This article is part of the Kotlin Primer, an opinionated guide to the Kotlin language, which is indented to help facilitate Kotlin adoption inside Java-centric organizations. It was originally written as an organizational learning resource for Etnetera a.s. and I would like to express my sincere gratitude for their support.

It is recommended to read the Introduction before moving on. Check out the Table of Contents for all articles.

One of the differences between Java and Kotlin is how each language handles constructors.

In Java, constructors are methods with a special name. There can be any number of them, or none at all. They are all equivalent in terms of their properties — one is no more special than the other.

// A simple java class with a simple constructor
class MyIntegerJava {
    Integer myInteger;
    
    public MyIntegerJava(Integer integer) {
        myInteger = integer;
    }
}

In Kotlin, there are actually two different types of constructors — primary and secondary. Secondary constructors are basically no different from regular Java constructors, and we’ll talk about them in a bit.

Primary Constructors

Primary constructors (a concept taken directly from Scala) are special, because the body of the primary constructor is merged with the class definition. In other words, the class definition can also be interpreted as the primary constructor body.

If you need to execute code other than assignments, use an initializer block, denoted by init:

Code in initializer blocks effectively becomes part of the primary constructor. Multiple init blocks can be used - in that case, they are executed in order:

This can be useful if you have multiple properties that need custom initialization, and don’t want to mix all the code together.

This whole concept might seem weird, but it helps to realize that Java already allows almost all of this.

import java.util.Arrays;
import java.util.Collections;

class FiveFivesJava {
    List<String> fiveFives = new ArrayList<>();
    
    // Initializer block, see 
    // https://docs.oracle.com/javase/tutorial/java/javaOO/initial.html
    {
        for (int i = 0; i <= 4; i++) {
            fiveFives.add("Fives" + i);
        }
    }
}

The only thing that’s new in Kotlin is the header of the primary constructor (arguments and optional modifiers/annotations). For more information on the execution order in Java, as well as an explanation of why you should make absolutely sure you only call private or final methods during construction, see here.

In Kotlin, you can (and should) go one step further.

Notice that the only purpose of the integer argument was to be immediately assigned to a property. If only we could somehow say "this class has these properties, and expects their values to be specified as constructor arguments".

As it turns out, in Kotlin, we can:

Awesome!

Remember, primary constructor arguments behave like any other arguments, and all the features that apply to normal function arguments (such as default values, named parameters, etc.) apply to primary constructor arguments as well.

Secondary constructors

Classes can also declare secondary constructors, which are prefixed with constructor. Every secondary constructor must call the primary constructor, either directly or through another secondary constructor. This is done immediately via the this() keyword (a matching constructor is selected based on the signature).

Exercises

The following class represents an immutable Person object. Since we haven’t discussed properties in Kotlin yet, we purposefully avoid the usage of getters and setters for now, and use public final fields. We wish to be able to easily construct Persons with any combination of the fields (i.e. only title + lastName, or firstName + middleName + lastName, etc.). We solve this by adding a builder class.

We also want to simplify the object construction for certain “common cases” e.g. we want to be able to write new Person(“Harry”, “Potter”) instead of having to write

new Person.Builder()
    .setFirstName(“Harry”)
    .setLastName(“Potter”)
   .buildPerson()

As “common cases”, we (randomly) pick “title + firstName + middleName + lastName” and “firstName + lastName”. We would also like to include the combination “title + lastName” (e.g. Mr. Bean), but in this case, we have no option but to use the builder.

The class implementation follows. Your task is to provide the same functionality in Kotlin, so you experience firsthand how much simpler things get.

public class PersonJava {
    public final String title;
    public final String firstName;
    public final String middleName;
    public final String lastName;

    public Person(
            String title, 
            String firstName, 
            String middleName, 
            String lastName
    ) {
        this.title = title;
        this.firstName = firstName;
        this.middleName = middleName;
        this.lastName = lastName;
    }

    public Person(
            String firstName, 
            String lastName
    ) {
        this("", firstName, "", lastName);
    }

    public static class Builder {
        private String title = "";
        private String firstName = "";
        private String middleName = "";
        private String lastName = "";

        public void setTitle(final String newTitle) {
            title = newTitle;
        }

        public void setFirstName(final String newFirstName) {
            firstName = newFirstName;
        }

        public void setMiddleName(final String newMiddleName) {
            middleName = newMiddleName;
        }

        public void setLastName(final String newLastName) {
            lastName = newLastName;
        }

        public Person buildPerson() {
            return new Person(
                    title, 
                    firstName, 
                    middleName, 
                    lastName
            );
        }
    }
}

Go back to Basic Class Syntax, jump to the Table of Contents, or continue to Properties — Introduction.