OOP in Kotlin

Class Basics

A class in Kotlin is a blueprint for creating objects. Kotlin classes are final by default (cannot be extended) unless marked open.

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

val person = Person("Alice", 30)
println(person.name)  // Alice
println(person.age)   // 30
person.age = 31       // Allowed: age is var
// person.name = "Bob" // Compile error: name is val

The primary constructor is declared in the class header. Properties declared with val are read-only; var are mutable.

Primary Constructor with Init Block

The init block runs as part of the primary constructor. Use it for validation or computed properties:

class User(val name: String, val email: String) {
    init {
        require(name.isNotBlank()) { "Name must not be blank" }
        require(email.contains("@")) { "Invalid email" }
    }
}

Secondary Constructors

Secondary constructors are declared inside the class body. Each must delegate to the primary constructor or another secondary constructor:

class Logger(val tag: String) {
    constructor() : this("DEFAULT")
    constructor(prefix: String, tag: String) : this("$prefix:$tag")
}

val log1 = Logger()              // tag = DEFAULT
val log2 = Logger("APP")         // tag = APP
val log3 = Logger("APP", "DB")   // tag = APP:DB

Property Declarations

Properties declared in the class body (not in the constructor) need explicit initialization or a custom getter:

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

    var label: String = "untitled"
        set(value) {
            field = value.uppercase()
        }
}

val rect = Rectangle(5.0, 3.0)
println(rect.area)    // 15.0
rect.label = "box"
println(rect.label)   // BOX

The field keyword is the backing field. Use it in custom accessors to avoid infinite recursion.

Open Classes and Inheritance

By default, Kotlin classes are final. Mark a class open to allow inheritance:

open class Animal(val name: String) {
    open fun speak(): String = "..."
}

class Dog(name: String) : Animal(name) {
    override fun speak(): String = "Woof!"
}

class Cat(name: String) : Animal(name) {
    override fun speak(): String = "Meow!"
}

val dog = Dog("Rex")
println("${dog.name} says ${dog.speak()}")  // Rex says Woof!

The override keyword is required when overriding a method. Methods are not open by default.

Abstract Classes

Abstract classes cannot be instantiated directly. They combine abstract (unimplemented) and concrete methods:

abstract class Shape {
    abstract fun area(): Double
    fun describe(): String = "Area: ${area()}"
}

class Circle(val radius: Double) : Shape() {
    override fun area(): Double = Math.PI * radius * radius
}

class Rectangle(val w: Double, val h: Double) : Shape() {
    override fun area(): Double = w * h
}

Interfaces

Interfaces define contracts without implementation state. A class can implement multiple interfaces:

interface Drawable {
    fun draw()
}

interface Resizable {
    fun resize(factor: Double)
}

class Canvas(val width: Double, val height: Double) : Drawable, Resizable {
    override fun draw() = println("Drawing ${width}x$height canvas")
    override fun resize(factor: Double) {
        // Modify dimensions
    }
}

Interfaces can have default implementations (unlike Java 7) and can declare properties (abstract or with accessors).

Object Declarations and Companions

An object declaration creates a singleton:

object DatabaseConfig {
    val host = "localhost"
    val port = 5432
}

println(DatabaseConfig.host)  // Access directly, no instantiation

A companion object provides static-like members to a class:

class User private constructor(val name: String) {
    companion object {
        fun create(name: String): User {
            return User(name)
        }
    }
}

val user = User.create("Alice")  // Factory method via companion

Data Classes

Data classes automatically generate equals(), hashCode(), toString(), copy(), and destructuring:

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)
println(p1)                 // Point(x=1, y=2)

val p3 = p1.copy(y = 5)    // Point(x=1, y=5)
val (x, y) = p1             // Destructuring: x=1, y=2

Sealed Classes

Sealed classes restrict inheritance to a fixed set of subclasses. They are essential for modeling state machines and algebraic data types:

sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
    object Loading : Result()
}

fun handleResult(result: Result): String {
    return when (result) {
        is Result.Success -> "Data: ${result.data}"
        is Result.Error -> "Error: ${result.message}"
        Result.Loading -> "Loading..."
        // No else branch needed: compiler knows all cases
    }
}

The compiler exhausts all cases in when expressions, so you get a compile error if a new subclass is added and the when is not updated.