• primary
• secondary

E.g. To create an empty StringBuilder object, we can write

val sb = StringBuilder()

but if we want to create a StringBuilder object and also initialize its content to Initial, we can write

val sb = StringBuilder("Initial")

The simplest class is an empty class. It's defined in either of these ways:

class Empty1 {}
class Empty2

E.g., after the above definition of Empty1 and Empty2 classes we can create new objects of those types by writing

val e1 = Empty1()
val e2 = Empty2()

Of course you can't do much else with an empty class! Note that the pair of parentheses is needed when instantiating objects, just like it’s needed when calling a function.

E.g., we can declare a Person class like this:

class Person {
    var firstName: String = "Samuel"
    var lastName: String = "Adams"
    var age: Int = 297
}

Note that every non-abstract property must be initialized somewhere within the class definition. The Kotlin compiler will be unhappy if you fail to properly initialize properties and will refuse to compile your program.

Once declared, we can do

fun main(args: Array<String>) {
    val person = Person()
    println("${person.firstName} ${person.lastName}, ${person.age}")

    person.firstName = "Benjamin"
    person.lastName = "Franklin"
    person.age = 313
    println("${person.firstName} ${person.lastName}, ${person.age}")
}

The program will print

Samuel Adams, 297
Benjamin Franklin, 313

It is of course a pain in the neck having to initialize the properties of every new object this way—by changing their values from the default after the object has already been created. It would be a lot nicer if we can initialize their values right at object instantiation time. We'll learn in the next few slides that is indeed possible.

1. a backing field to keep its value,
2. a get function to access this value, and also
3. a set function if the property is a var property.

We can override Kotlin's default behavior on properties by providing our own get function, e.g.

class Rectangle {
    val height: Int = 10
    val width: Int = 20
    val isSquare: Boolean
        get() { return height == width }
}

It is customary for the name of a Boolean property to have the “is” prefix. In fact, you should name all your Boolean property like that if your Kotlin code needs to interoperate with Java code. The Kotlin compiler relies on such a convention.

We can also override Kotlin's default set function with our own, e.g.

class Person {
    var firstName: String = "Samuel"
    var lastName: String = "Adams"
    var age: Int = 96
        set(value) {
            if (value !in 0..150)
                throw Exception("$value is out of range")
            else
                field = value
        }
}

A keyword in this context is field. It's the name of the backing field for the property. You don't have to declare it or its type. The compiler already knows what field means and what its type is!

The primary constructor, if exists, is declared in the class header right after the class name, by using the word constructor followed by a comma-separated list of “parameter: type” declarations and enclosed in a pair of parentheses, like this:

class Person constructor(_firstName: String, _lastName: String, _age: Int) {
    ...
}

In fact, when the word constructor is not preceded by annotations or visibility modifiers, like in the declaration above, it can be safely dropped. So the above declaration is equivalent to the shorter

class Person(_firstName: String, _lastName: String, _age: Int) {
    ...
}

Initial values used to initialize the properties of a new class instance are usually fed to the constructor through its parameters. However, the primary constructor has no body, so Kotlin provides initializer blocks for initialization. Whenever the primary constructor is called, the code in all initializer blocks are executed in the order they are written in the class definition. E.g., the Person class with a primary constructor can be written like this

class Person(_firstName: String, _lastName: String, _age: Int) {
    var firstName: String
    var lastName: String
    var age: Int
    init {
        firstName = _firstName
        lastName = _lastName
        age = _age
    }
}

The above code pattern occurs so often that Kotlin provides this shorthand notation for writing it:

class Person(var firstName: String, var lastName: String, var age: Int)

Of course, parameters of the primary constructor can have default values like this:

class Person(
    var firstName: String,
    var lastName: String = "UNKNOWN",
    var age: Int = 0
) { ... }

It’s posssible for a class to not have a primary constructor. In that case, every property must have a default value, or have its value initialized in some initializer block.

• It is declared within the class body.
• It can have a code body just like a normal function definition.
• If the class has a primary constructor, the secondary constructor must delegate to the primary constructor (or to other secondary constructor which must ultimately delegate to the primary constructor) before executing the code in its body. The delegation to the other constructor is done via the this keyword.

Here is an example class definition with a secondary constructor definition.

class Person(var firstName: String, var lastName: String, var age: Int) { 
    var middleName: String = ""

    constructor(firstName: String, middleName: String): this(firstName, "Unknown", 0) {
        this.middleName = middleName
    }
}

Note that the keyword this is used at two different places. The first use in this(firstName, "Unknown", 0) is a call to the primary constructor. The second use in this.middleName = middleName references “this object”—the runtime class instance that is executing this code. We need it here in order to reference the middleName property. Writing middleName instead of this.middleName would reference the secondary constructor’s second parameter instead!

The compiler determines which constructor is being called by matching the arguments of the call with the constructors’ signatures. E.g., if one writes

val person1 = Person("John", "Doe", 20)

then the primary constructor will be invoked, but if one writes

val person2 = Person("William", "Henry")

This implies that no two constructors can have the same signature.

Here is an example class definition that declares two var properties, and defines one primary constructor and two member functions.

class Point(var x: Double = 0.0, var y: Double = 0.0) {
    fun translate(xAmount: Double, yAmount: Double) {
        x += xAmount
        y += yAmount
    }

    fun show() {
        StdDraw.point(x, y)
    }
}