Classes & Objects

// val/var on a constructor parameter makes it a property automatically:
// no separate field declaration, no assignment boilerplate
class User(val name: String, val age: Int)

val user = User("Ada", 36)
println(user.name) // Ada: name is a real, readable property

// Constructor parameters without val/var are just parameters:
// usable in init blocks, not exposed as properties
class Circle(radius: Double) {
    val area = Math.PI * radius * radius
    // "radius" itself isn't accessible outside the constructor
}

// Default values work here too, same as any function
class Connection(val host: String, val port: Int = 443)

// init blocks run as part of the primary constructor, in the order
// they're declared, interleaved with property initializers
class Account(val owner: String, initialBalance: Int) {
    val balance: Int

    init {
        require(initialBalance >= 0) { "balance can't be negative" }
        balance = initialBalance
        println("Account created for $owner")
    }

    init {
        println("Second init block: still runs in declaration order")
    }
}
// Account("Ada", -5) throws IllegalArgumentException immediately

// Every secondary constructor must delegate to the primary,
// directly or through another secondary constructor, via this(...)
class Point(val x: Int, val y: Int) {
    constructor() : this(0, 0)                // origin
    constructor(both: Int) : this(both, both)  // on the diagonal
}

Point()      // (0, 0)
Point(5)     // (5, 5)
Point(1, 2)  // (1, 2)

class Rectangle(val width: Double, val height: Double) {
    // Computed property: no backing field, recalculated on every read
    val area: Double
        get() = width * height
}

class User(name: String) {
    // "field" refers to the auto-generated backing field;
    // without referencing it, there'd be no storage at all
    var name: String = name
        set(value) {
            require(value.isNotBlank()) { "name can't be blank" }
            field = value.trim()
        }
}

val u = User("  Ada  ")
println(u.name)     // "Ada": trimmed by the setter at construction time too
u.name = "Grace"  // goes through the same validation

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

val p1 = Point(1, 2)
val p2 = Point(1, 2)

println(p1 == p2)       // true: structural equality, not reference identity
println(p1 === p2)      // false: different instances
println(p1)             // Point(x=1, y=2): readable toString() for free
println(p1.hashCode() == p2.hashCode()) // true: consistent with equals

// Every possible outcome is a subtype; no other subtype can exist
sealed class NetworkResult
data class Success(val data: String) : NetworkResult()
data class Failure(val error: Throwable) : NetworkResult()
object Loading : NetworkResult()

fun render(result: NetworkResult): String = when (result) {
    is Success -> "Data: ${result.data}"   // smart-cast to Success
    is Failure -> "Error: ${result.error.message}"
    Loading    -> "Loading..."
    // no else needed — and none allowed to compensate for a missing case
}

// Useful when subtypes don't share a natural common base class,
// or a subtype already extends something else
sealed interface UiState
object Idle : UiState
data class Ready(val items: List<String>) : UiState
data class Error(val message: String) : UiState, Comparable<Error> {
    override fun compareTo(other: Error) = message.compareTo(other.message)
}

enum class Planet(val massKg: Double, val radiusM: Double) {
    MERCURY(3.303e23, 2.4397e6),
    EARTH(5.976e24, 6.37814e6);

    // Regular member: available on every constant
    fun surfaceGravity(): Double {
        val g = 6.67300E-11
        return g * massKg / (radiusM * radiusM)
    }
}

println(Planet.EARTH.surfaceGravity())

// entries: a modern, allocation-free replacement for values()
for (planet in Planet.entries) {
    println("${planet.name}: ${planet.ordinal}")
}

// Each constant can override an abstract member with its own body
enum class Operation {
    PLUS {
        override fun apply(a: Int, b: Int) = a + b
    },
    TIMES {
        override fun apply(a: Int, b: Int) = a * b
    };

    abstract fun apply(a: Int, b: Int): Int
}

println(Operation.PLUS.apply(2, 3))  // 5
println(Operation.TIMES.apply(2, 3)) // 6

// Exactly one instance exists, created on first access
object AppConfig {
    var environment: String = "production"
    fun isDebug() = environment == "debug"
}

AppConfig.environment = "debug"
println(AppConfig.isDebug())  // true: same instance everywhere

// object can implement interfaces, useful for stateless implementations
interface Logger { fun log(msg: String) }
object ConsoleLogger : Logger {
    override fun log(msg: String) = println("[LOG] $msg")
}

class User private constructor(val name: String) {
    companion object {
        // A factory function, called on the type itself: User.create(...)
        fun create(rawName: String): User? {
            val trimmed = rawName.trim()
            return if (trimmed.isBlank()) null else User(trimmed)
        }

        const val MAX_NAME_LENGTH = 100  // compile-time constant
    }
}

val user = User.create("  Ada  ")
println(User.MAX_NAME_LENGTH)  // 100

// A companion object is a real object with a name (default: Companion),
// and can implement interfaces, just like any object

interface SoundSource {
    fun play(): String
}

class Speaker : SoundSource {
    override fun play() = "playing through speaker"
}

// MediaPlayer implements SoundSource entirely by forwarding to `source`.
// No play() body needed here unless you want to override it.
class MediaPlayer(source: SoundSource) : SoundSource by source

val player = MediaPlayer(Speaker())
println(player.play()) // "playing through speaker"

// You can still override individual members selectively
class LoudPlayer(source: SoundSource) : SoundSource by source {
    override fun play() = "${source.play()} at max volume"
}

class BankAccount(private val pin: String) {

    public val accountId: String = generateId()
    // public is the default: "public val accountId" and "val accountId"
    // mean exactly the same thing

    private var balance: Int = 0
    // visible only inside this class

    protected open fun auditLog(): String = "account $accountId"
    // visible in this class and subclasses only

    internal fun rawBalance() = balance
    // visible anywhere in the same module, not to external consumers
    // of a published library — Java has no equivalent to this level
}

class Outer(val name: String) {
    // Nested class: cannot see Outer's members, needs no Outer instance
    class Nested {
        fun greet() = "hello from a nested class"
    }
}

// Constructed without any Outer instance
val n = Outer.Nested()
println(n.greet())

class Outer(val name: String) {
    inner class Inner {
        // Can reach Outer's members directly, because this Inner
        // instance is tied to the Outer instance that created it
        fun describe() = "inner class of $name"

        // this@Outer disambiguates when both classes share a member name
        fun outerName() = this@Outer.name
    }
}

// Must be constructed through an Outer instance
val outer = Outer("config")
val inner = outer.Inner()
println(inner.describe()) // "inner class of config"