Kotlin Object Declaration

An object declaration in Kotlin is a language-level construct that simultaneously defines a class and creates a single, thread-safe instance of it, natively implementing the Singleton design pattern. Because the declaration creates the instance directly, you access its members using the object’s name rather than instantiating it via a constructor call.

Syntax and Structure

An object declaration is defined using the object keyword followed by a name. It can contain properties, functions, and init blocks.

object ConfigurationRegistry {
    var isInitialized: Boolean = false
    
    fun register() {
        isInitialized = true
    }
}

// Accessed directly via the object name
ConfigurationRegistry.register()

Technical Characteristics

1. Constructor Restrictions Object declarations cannot have primary or secondary constructors. Because the instantiation is handled automatically by the Kotlin compiler, passing parameters during creation is not supported. Any startup logic must be placed within an init block. 2. Scope Restrictions Object declarations cannot be local (i.e., they cannot be declared directly inside a function). If a developer needs an anonymous or local object, they must use an object expression instead. 3. Lazy Initialization and Thread Safety The initialization of an object declaration is lazy. The instance is created only when it is accessed for the first time. The Kotlin compiler guarantees thread-safe initialization by leveraging the JVM’s class initialization locks under the hood (translating the object to a Java class with a static final instance). 4. Inheritance Object declarations can inherit from open classes and implement interfaces. When extending a class, the object must provide the required constructor parameters to the superclass directly in the declaration.

open class BaseService(val protocol: String)
interface RunnableService {
    fun execute()
}

object NetworkService : BaseService("HTTPS"), RunnableService {
    init {
        println("NetworkService initialized lazily.")
    }

    override fun execute() {
        println("Executing over $protocol")
    }
}

Companion Objects

An object declaration placed inside a class or interface can be marked with the companion keyword. This binds the object’s lifecycle and access to the enclosing type itself, providing mechanics similar to static members in Java.

class Entity private constructor(val id: String) {
    companion object Factory {
        const val DEFAULT_ID = "0000"
        
        fun createDefault(): Entity {
            return Entity(DEFAULT_ID)
        }
    }
}

// Accessed via the enclosing class name
val entity = Entity.createDefault()

Note: The name of the companion object (e.g., Factory) is optional. If omitted, it defaults to Companion.

Data Objects

Kotlin 1.9.0 introduced the data object declaration. While a standard object uses default reference-based equality and a memory-address-based toString() representation, a data object instructs the compiler to generate symmetric toString(), equals(), and hashCode() implementations based on the object’s name.

data object EndOfStream

// EndOfStream.toString() outputs "EndOfStream" instead of "EndOfStream@5a07e868"

Tired of Poor Kotlin Skills? Fix That With Deep Grasping!Learn More

Functions

Lambdas

Classes & Types

Interfaces

Object Constructs

Constructors

Extensions

Properties

Delegation

Generics

Variables

Parameters

Control Flow

Loops

Error Handling

Annotations

Packages & Imports

Built-In Types

Comments

Arithmetic Operators

Assignment Operators

Equality Operators

Comparison Operators

Containment Operators

Logical Operators

Null Safety Operators

Unary Operators

Type Check & Cast Operators

Range Operators

Bitwise Operators

Shift Operators

Kotlin Object Declaration

Syntax and Structure

Technical Characteristics

Companion Objects

Data Objects

​Syntax and Structure

​Technical Characteristics

​Companion Objects

​Data Objects

Syntax and Structure

Technical Characteristics

Companion Objects

Data Objects