Lesson 11. Object Declarations and Companion Objects

Mission link: Lesson 10 covered enum constants as singleton objects, without covering the standalone object keyword itself. This lesson is that keyword, and companion objects, the construct most directly replacing a Java habit: reaching for static out of reflex.
Primary source: Docs: "Object declarations and expressions", Kotlin
Prerequisites: Lesson 10, Platform type

Warm-up

1. ▢ Why can enum class Color(val rgb: Int) { RED(0xFF0000), ... } give each constant its own distinct value?

2. ▢ What signal suggests a set of enum constants would actually fit a sealed class better?

Know this

object declares a class and creates its one instance, in one step

object DataProviderManager { ... } does two things at once: it defines a class, and it creates the single instance of that class that will ever exist, both in one declaration. This is Kotlin's built-in way to implement the singleton pattern (exactly one instance of a class, globally accessible) without the manual boilerplate Java requires (a private constructor, a static instance field, a static accessor method, and often extra care to make it thread-safe). Referring to the object uses its name directly, DataProviderManager.registerDataProvider(...), no separate instantiation step anywhere.

The singleton's initialization is thread-safe and lazy, by the language itself

An object declaration's initialization happens on first access and is guaranteed thread-safe by Kotlin itself; this is exactly the kind of correctness detail a hand-written Java singleton has to get right deliberately (double-checked locking, an eagerly-initialized static field, or an enum-based singleton trick), and Kotlin provides it as a language guarantee instead of a pattern to implement correctly by hand.

A companion object replaces Java's static members

Kotlin has no static keyword at all; a class's members are always instance members. What replaces Java's static fields and methods is a companion object: class MyClass { companion object { fun create(): MyClass = MyClass() } } declares an object tied to the class itself (at most one companion object per class), whose members are accessed via the class name directly (MyClass.create()), the same call-site syntax Java's static methods use. This is a deliberate design choice, not an oversight: a companion object is a real object, meaning it can implement interfaces, have its own supertype, and be passed around as a value where a static member never could be.

Companion objects are commonly used for factory functions

A very common use of a companion object is a factory function, a function that constructs and returns an instance, standing in for (or alongside) a constructor: class User private constructor(val name: String) { companion object { fun create(name: String): User? = if (name.isNotBlank()) User(name) else null } }. This lets construction include logic a plain constructor can't (validation that might fail, returning a cached instance instead of a new one, choosing between subclasses), while still reading at the call site (User.create("Ada")) almost exactly like calling a constructor.

Practice

1. ▢ What two things does an object declaration do in one step, and how does this compare to Java's manual singleton pattern?

2. ▢ Why is a companion object described as a real object, and why does that matter compared to Java's static members?

3. ▢ Why does construction via a companion object factory function (User.create("Ada")) sometimes fit better than a plain public constructor?

4. ▢ A team writes object Logger { fun log(message: String) { println(message) } } and calls Logger.log("started") from many places in their codebase. What does the object declaration guarantee here that a plain class with a log method wouldn't?

5. ▢ Which claim correctly describes object declarations and companion objects?

   • a) Kotlin has a static keyword, used the same way Java's is
   • b) object declares a class and its single instance together, with thread-safe lazy initialization guaranteed by the language; a companion object is Kotlin's replacement for Java's static members, and unlike a static member, it's a real object that can implement interfaces or be passed as a value
   • c) A companion object can only contain factory functions, no other kind of member
   • d) Every class must have exactly one companion object

Real-world reps

• [ ] Find an object declaration in a codebase you've written or have access to. Confirm you can explain why a singleton is the right fit for it (a shared resource, a stateless utility) rather than an ordinary class.
• [ ] Find a companion object, especially one used as a factory function. Check whether it does something a plain constructor couldn't (validation, caching, subclass selection), or whether it's just a stylistic wrapper around a constructor call.
• [ ] Tomorrow: read the primary source's section on object expressions (anonymous, one-time objects) in full, and note how they differ from a named object declaration, particularly around whether they create a shared singleton or a fresh instance each time.

Going further

• Docs: "Object declarations and expressions", Kotlin
• Docs: "Classes", Kotlin
• Resources

Not landing? Reread the primary source at the top, since this lesson compresses it and compression is where understanding leaks. Check the glossary for any term that felt slippery.

If the lesson itself is unclear rather than the material, that is a defect: open an issue.