Kotlin Objects and Companion Objects

object Settings {
    var darkMode = false
    val version = "2.4.1"
    fun summary() = "v$version, dark mode: $darkMode"
}

Settings.darkMode = true
println(Settings.summary())

• Use the object's name directly; there's no constructor and no Settings() call.
• The instance is created lazily the first time it's accessed, and it's thread-safe.
• Objects can implement interfaces and extend classes, like any class.
• Every part of the program sees the same instance, so changes are shared.

A companion object lives inside a class. Its members are called on the class name, like static members in other languages:

class User private constructor(val name: String) {
    companion object {
        const val MAX_NAME = 20
        fun create(name: String): User? =
            if (name.isBlank() || name.length > MAX_NAME) null else User(name.trim())
    }
}

val u = User.create("Ada")

• const val constants in a companion are a common home for class-related constants.
• A private constructor plus a companion function creates a factory: the only way to make a User is through create, which validates the input.
• There's one companion per class, shared by all its objects.

An object expression creates a one-off object right where you need it, usually to implement an interface without writing a named class:

val logger = object : Logger {
    override fun log(msg: String) = println("[app] $msg")
}

This is useful for small listeners and test doubles. When the interface has a single function, a lambda is often shorter still, using a fun interface.

A data object (Kotlin 1.9 and later) is a singleton with a readable toString(), which is handy in sealed hierarchies such as data object Loading : State().

Not everything needs an object. Kotlin allows top-level functions and properties, declared in a file outside any class. For a general utility like fun formatPrice(...), a top-level function is simpler than wrapping it in an object. Use objects when you need shared state, an interface implementation or a clear grouping.

A companion object is a real object, so it can implement an interface. That lets you pass the class name itself wherever the interface is expected, which is a tidy way to attach a parser or factory to a type:

interface Parser<T> {
    fun parse(text: String): T
}

data class Colour(val r: Int, val g: Int, val b: Int) {
    companion object : Parser<Colour> {
        override fun parse(text: String): Colour {
            val (r, g, b) = text.split(",").map { it.trim().toInt() }
            return Colour(r, g, b)
        }
    }
}

fun <T> readAll(lines: List<String>, parser: Parser<T>) = lines.map(parser::parse)

println(Colour.parse("255, 0, 10"))            // Colour(r=255, g=0, b=10)
println(readAll(listOf("1,2,3", "4,5,6"), Colour))

In the last line, Colour on its own refers to the companion object, so it can be handed to readAll like any other Parser. A companion can also be given a name, as in companion object Factory, but most code leaves it unnamed and calls members through the class name.

Both declare a value that never changes, but they're not the same:

So const val MAX_NAME = 20 is fine, but const val START = LocalDate.of(2024, 1, 1) fails with "Only primitive types and 'String' are allowed". Use a plain val for anything built by calling a function.

When an object exists only to implement a single-function interface, a fun interface with a lambda is shorter still: val logger = Logger { println("[app] $it") } creates the implementation in one line.