Kotlin Classes and Objects

class Player(val name: String, var score: Int = 0) {
    fun addPoints(points: Int) {
        score += points
    }
}

val p = Player("Ana")
p.addPoints(10)
println("${p.name}: ${p.score}")    // Ana: 10

• The brackets after the class name are the primary constructor.
• val and var in the constructor create properties: name can't change, score can.
• Parameters can have default values, just like functions.
• Create an object by calling the class like a function. There's no new.
• Methods are functions inside the class and can use the properties directly.

Code in an init block runs when an object is created, which makes it the place to check that the data is valid:

class Temperature(val celsius: Double) {
    init {
        require(celsius >= -273.15) { "Below absolute zero: $celsius" }
    }
}

require(condition) { message } throws an IllegalArgumentException if the condition is false. Checking data at creation means every object of the class is guaranteed to be valid, so the rest of your code doesn't have to keep checking.

A property can calculate its value every time it's read with a custom getter:

class Rectangle(val width: Double, val height: Double) {
    val area: Double get() = width * height
}

A custom setter runs when a var is assigned; field is the stored value:

var name: String = ""
    set(value) { field = value.trim() }

Control who can see what with visibility modifiers: public (the default, visible everywhere), private (only inside the class), protected (the class and its subclasses) and internal (the same module). var balance = 0.0 private set lets anyone read the balance but only the class change it.

Most classes need only the primary constructor, often with default values. If you need another way to create objects, add a secondary constructor with constructor(...), which must call the primary one with this(...).

lateinit var declares a non-null property that will be set later, for example after a screen is created in Android. Reading it before it's set throws an exception, so use it sparingly; a nullable type or a default value is usually safer.

When you assign an object to another variable, Kotlin doesn't copy it. Both names point at the same object, so a change through one is visible through the other:

val a = Player("Ana")
val b = a
b.score = 20
println(a.score)        // 20

fun bonus(p: Player) { p.score += 5 }
bonus(a)
println(a.score)        // 25

The same happens when you pass an object to a function: bonus receives a reference to Ana's player, not a copy, so its change sticks. The val in val a only stops a from being pointed at a different player; it doesn't freeze the player's own var properties.

This also explains how ordinary classes compare. === asks "are these the very same object?", and for a plain class, == asks the same question unless you override equals. Two separate players with identical names and scores are not equal:

println(Player("Ana", 25) == Player("Ana", 25))   // false
println(a === b)                                  // true

Printing a plain object shows its class name and a code such as Point@1b6d3586, which isn't much help. Override toString to choose what's printed:

class Player(val name: String, var score: Int = 0) {
    override fun toString() = "Player($name, $score)"
}

If you find yourself writing equals and toString by hand for a class that mainly holds data, a data class generates both for you.