Classes & Data Classes

🏗️ Classes & Data Classes

🧱 The Primary Constructor

Kotlin classes declare their constructor parameters directly in the class header, and can turn them into properties with a single keyword:

Copyclass Person(val name: String, var age: Int)

val p = Person("Alice", 30)
println(p.name)   // Alice
println(p.age)    // 30
p.age = 31            // fine — age is a var property
// p.name = "Bob"      // compile error — name is a val property

val and var inside the constructor parentheses do two things at once: declare the parameter and promote it to a property of the class, automatically generating a getter (and a setter, for var). There's no separate field declaration, no this.name = name assignment, and no hand-written getter/setter — all of that Java ceremony collapses into the single constructor line.

⚙️ Init Blocks & Body Properties

Logic that needs to run at construction time goes in an init block; properties that aren't simple constructor parameters are declared in the class body:

Copyclass Person(val name: String, var age: Int) {
    val isAdult: Boolean

    init {
        require(age >= 0) { "Age cannot be negative" }
        isAdult = age >= 18
        println("Created Person: $name")
    }

    fun greet() = "Hi, I'm $name"
}

require(...) throws an IllegalArgumentException if the condition is false — Kotlin's built-in, one-line way of validating constructor arguments, instead of writing an explicit if and throw.

📋 Data Classes

Adding the data keyword to a class generates equals(), hashCode(), toString(), and copy() automatically, based on the constructor properties:

Copydata class Point(val x: Int, val y: Int)

val a = Point(1, 2)
val b = Point(1, 2)

println(a)          // Point(x=1, y=2) — auto-generated toString()
println(a == b)     // true — auto-generated equals(), compares values not references

📄 copy()

Data classes also generate a copy() function, which creates a new instance with the same values, except for whichever properties you explicitly override:

Copydata class User(val name: String, val age: Int, val isAdmin: Boolean = false)

val original = User("Alice", 30)
val birthday = original.copy(age = 31)
val promoted = original.copy(isAdmin = true)

println(original)    // User(name=Alice, age=30, isAdmin=false) — unchanged
println(birthday)    // User(name=Alice, age=31, isAdmin=false)
println(promoted)    // User(name=Alice, age=30, isAdmin=true)

This pairs naturally with everything from Chapter 1 — data classes are usually built from val properties, so copy() is the standard way to produce an "updated" version without ever mutating the original. It's the same immutable-update pattern as JavaScript's spread syntax ({ ...user, age: 31 }), but type-checked and built into the class itself.

🏢 Companion Objects

Kotlin has no static keyword. Instead, members that belong to the class itself (not an instance) live inside a companion object:

Copyclass User private constructor(val name: String) {
    companion object {
        fun guest() = User("Guest")
    }
}

val g = User.guest()   // called on the class itself, like a Java static method
println(g.name)      // Guest

The call syntax looks identical to Java's static call — User.guest() — but under the hood, a companion object is a real singleton object tied to the class, which is why it can also implement interfaces or hold its own properties, something a Java static block can't do.

💻 Coding Challenges

🎯 What's Next

Next chapter: Inheritance & Interfaces — open/abstract classes, interfaces, polymorphism, and sealed classes.