What does an `object` declaration create in Kotlin, and how is it different from a regular `class`?
answer
- object = type + single instance in one keyword
- No constructor, no constructor params
- Reference by name: Name.member
- Replaces private-ctor + getInstance Java idiom
- Can implement interfaces / extend a class
basics
~10 sAn object declaration creates a singleton: exactly one instance that Kotlin makes for you. You never call a constructor. You use it by its name, like Counter.next().
solid answer
~40 sAn `object` declaration defines a class and its single instance at the same time. The compiler guarantees exactly one instance exists for the whole program. Unlike a `class`, you cannot write a constructor or call `new`/invoke it to make more instances — you reference it directly by name (`Logger.log(...)`). It can have properties, functions, `init` blocks, implement interfaces, and extend a class. It is created lazily: the instance is initialized on first access, and that initialization is thread-safe because Kotlin compiles it to a `static final` field initialized in a static initializer. This is the idiomatic replacement for the hand-written Java singleton (private constructor + static getInstance).
code
kotlin · 9 linesobject Registry {
private val items = mutableListOf<String>()
fun add(item: String) { items += item }
fun all(): List<String> = items.toList()
}
Registry.add("a")
Registry.add("b")
println(Registry.all()) // [a, b]go deeper
Knows object = singleton, accessed by name, no constructor call.
Explains it can implement interfaces/extend a class and has no constructor params; maps it to the Java idiom.
Adds the compiled INSTANCE field and Java interop (@JvmStatic), plus init-block configuration.
Discusses when a singleton object is appropriate vs. injectable dependency, and testability trade-offs.
## What `object` declares An **object declaration** combines two things in one keyword: it *defines a type* and *creates the single instance of that type*. It is Kotlin's built-in **singleton** — a class guaranteed to have exactly one instance. ```kotlin object AppConfig { val version = "1.0" fun describe() = "KataJob v$version" } // Usage — reference by name, no constructor call: val v = AppConfig.version println(AppConfig.describe()) ``` ## How it differs from a `class` - A `class` is a blueprint; you create instances with a constructor (`val c = Counter()`). An `object` *is* the instance — there is no constructor and no way to make a second one. - An `object` **cannot have a primary or secondary constructor**, so it can't take constructor parameters. (It can still have an `init` block.) - You access members through the object's name: `AppConfig.version`. The name resolves to the single instance. ## What it can contain An object can have: - properties and functions, - an `init { }` block for setup, - it can **implement interfaces** and **extend one open class**. ```kotlin interface Clock { fun now(): Long } object SystemClock : Clock { override fun now() = System.currentTimeMillis() } ``` ## Replacing the Java singleton idiom In Java you wrote: a `private` constructor, a `private static` field, and a `public static getInstance()`. In Kotlin that whole pattern collapses into `object Name { ... }`. The compiler generates a `public static final INSTANCE` field on the class and initializes it once, so you get correctness for free. ## Key keywords/APIs - `object` — the declaration keyword. - From Java you reach a Kotlin object via its `INSTANCE` field (`AppConfig.INSTANCE`). - `@JvmStatic` on members exposes them as true static members to Java callers (interop nicety, not required in Kotlin).
- Can an object declaration take constructor parameters?No. It has no constructor, so no parameters. Configure it via an `init` block or by reading from external sources/properties.
- How do you call an object's member from Java?Through the generated `INSTANCE` field: `AppConfig.INSTANCE.describe()`, or add `@JvmStatic` to call it statically.
A class is a cookie cutter; an object is the one cookie that already exists — there's only ever that one.
saying these in an interview costs you the question
- Saying you call a constructor or `new` to use an object
- Claiming an object can take constructor parameters
- Confusing `object` declaration with object expression (anonymous object)
- Thinking you must write getInstance yourself