Classes, data classes and objects

val, var and immutability

val declares a read-only reference; var a mutable one. Neither says anything about the object referred to. A val holding a MutableList can still be appended to. Kotlin's collection interfaces split the two roles: List has no add, MutableList does. Exposing List is how a class keeps a mutable list to itself:

1class Cart {2    private val _items = mutableListOf<String>()3    val items: List<String> get() = _items     // callers see a read-only view4    fun add(item: String) { _items += item }5}

A read-only view isn't a copy: if you need a snapshot, return _items.toList().

Data classes

1data class Money(val cents: Long, val currency: String) {2    var note: String = ""                      // not part of equals/hashCode/toString/copy3}4 5fun main() {6    val a = Money(500, "EUR").apply { note = "lunch" }7    val b = Money(500, "EUR")8    println(a == b)                            // true: only constructor properties count9    println(a)                                 // Money(cents=500, currency=EUR)10    val (cents, currency) = a                  // component1(), component2()11    println("$cents $currency")                // 500 EUR12    println(a.copy(cents = 750))               // Money(cents=750, currency=EUR)13}

data generates equals, hashCode, toString, copy and component1..N from the primary constructor properties only. copy is shallow. Data classes can't be open, abstract or sealed, which keeps equals symmetric.

== calls equals; === compares references. For a class without data (or your own equals), == is reference equality.

object and companion object

An object declaration defines a class and its single instance at once. On the JVM the instance is created in the class's static initialiser, so it is lazy (on first access) and thread-safe without any locking code of yours:

1object Clock {2    var offsetMillis = 0L3    fun now() = System.currentTimeMillis() + offsetMillis4}5 6class User private constructor(val name: String) {7    companion object {8        fun named(name: String): User = User(name.trim())   // a factory9    }10}11 12fun main() {13    println(User.named("  Ada ").name)          // Ada14    println(Clock.now() > 0)                     // true15}

A companion object is one such object nested in a class, reachable through the class name. It is a real object: it can implement interfaces and hold state, and from Java you reach it as User.Companion.named(...) unless you mark the function @JvmStatic. An object expression (object : Runnable { ... }) creates an anonymous one-off instance instead, like Java's anonymous classes.

Two other kinds are worth knowing: a value class wraps a single value with no allocation at runtime in most places (@JvmInline value class UserId(val raw: String)), and an enum class has a fixed set of instances. Sealed classes, the closed hierarchies used with when, have their own topic.