Types and Data

to is an infix function that builds a Pair. Read-only means the interface has no mutators, not that the object can never change. Expose read-only types and keep mutation inside the owning code.

Classes

The parentheses after a class name declare its primary constructor, and marking a parameter val or var turns it into a property. There is no new keyword. Classes and members are final by default, so you must mark them open to allow inheritance.

open class Animal(val name: String) {
    open fun sound(): String = "..."
    override fun toString() = "$name: ${sound()}"
}

class Dog(name: String, var age: Int) : Animal(name) {
    init {
        require(age >= 0) { "age must not be negative" }
    }

    val isPuppy: Boolean
        get() = age < 1          // computed on every read

    override fun sound() = "Woof"
}

fun main() {
    val dog = Dog("Rex", 3)
    dog.age += 1
    println(dog)          // Rex: Woof
    println(dog.isPuppy)  // false
}

init blocks run during construction, and properties can have custom getters and setters.

Data classes

For classes whose job is holding values, use data class. The compiler generates equals, hashCode, toString, copy and the componentN functions behind destructuring.

data class User(val id: Long, val name: String, val email: String? = null)

fun main() {
    val a = User(1, "Sam")
    val b = User(1, "Sam")
    println(a == b)              // true: compares property values
    println(a)                   // User(id=1, name=Sam, email=null)

    val renamed = a.copy(name = "Sammy")
    val (id, name) = renamed     // destructuring
    println("$id $name")         // 1 Sammy
}

== calls equals; use === for reference identity. The ? in String? marks a nullable type, covered in chapter 6.

Enums and sealed types

Use enum class for a fixed set of constants. When each case carries different data, use a sealed class or interface: its subtypes must live in the same module and package, so the compiler can check that a when is exhaustive.

import kotlin.math.PI

enum class Color(val hex: String) {
    RED("#FF0000"), GREEN("#00FF00"), BLUE("#0000FF");

    fun label() = name.lowercase()
}

sealed interface Shape
data class Circle(val radius: Double) : Shape
data class Rect(val width: Double, val height: Double) : Shape
data object Empty : Shape

fun area(shape: Shape): Double = when (shape) {   // no else needed
    is Circle -> PI * shape.radius * shape.radius
    is Rect -> shape.width * shape.height
    Empty -> 0.0
}

fun main() {
    println(Color.entries.map { it.label() })   // [red, green, blue]
    println(area(Rect(2.0, 3.0)))               // 6.0
}

Objects and companion objects

An object declaration defines a singleton. Kotlin has no static, so class-level factories and constants go in a companion object.

object AppConfig {
    var debug = false
    fun summary() = "debug=$debug"
}

class Temperature private constructor(val celsius: Double) {
    companion object {
        val FREEZING = Temperature(0.0)
        fun fromFahrenheit(f: Double) = Temperature((f - 32) * 5 / 9)
    }
}

fun main() {
    AppConfig.debug = true
    println(AppConfig.summary())                          // debug=true
    println(Temperature.fromFahrenheit(212.0).celsius)    // 100.0
    println(Temperature.FREEZING.celsius)                 // 0.0
}

Summary

• Numeric types never convert implicitly; call toLong() and similar.
• Collections split into read-only (listOf) and mutable (mutableListOf) variants.
• Classes are final by default, and val/var constructor parameters become properties.
• Data classes get equals, toString, copy and destructuring for free.
• Model closed sets of cases with enum or sealed; use object for singletons and companion object instead of statics.