Understanding the init Block in Kotlin

A Deep Dive with Bytecode examples

Why Does Kotlin Need init?

Imagine you’re setting up a new home. You buy furniture, install utilities, and decorate the space before moving in. In programming, when you create an object, you often need to initialize it with some values before using it. In Java, this was typically done using constructors, but Kotlin introduces a cleaner, more structured approach—the init block.

If you're transitioning from Java to Kotlin, you might wonder: Why do we need init blocks when we already have constructors?

---

---

Let’s explore this and see how Kotlin simplifies object initialization.

How Java Handles Initialization

In Java, we usually initialize objects inside constructors:

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

This works fine, but Java’s constructor approach can lead to boilerplate code, especially when dealing with multiple constructors or additional setup logic.

Kotlin addresses this with primary constructors and init blocks.

The init Block in Kotlin

Kotlin encourages concise code by allowing primary constructors without a body. However, if you need initialization logic, you use the init block:

class Person(val name: String, val age: Int) {
    init {
        println("Person is created: Name = $name, Age = $age")
    }
}

fun main() {
    val person = Person("Akshay", 25)
}

How init Works:

• The init block runs as soon as an instance is created.

• It executes before the secondary constructor (if any).

• You can have multiple init blocks; they execute in order of appearance.

Example of Multiple init Blocks

Kotlin allows multiple init blocks in a class:

class MultiInitExample(val name: String) {
    init {
        println("First init block: Name is $name")
    }
    
    init {
        println("Second init block: Name length is ${name.length}")
    }
}

fun main() {
    val example = MultiInitExample("Kotlin")
}

Bytecode Representation of init

Kotlin internally translates the init block into Java’s constructor. Let’s check the bytecode for better understanding.

class Example(val message: String) {
    init {
        println("Message is: $message")
    }
}

When decompiled to Java, it looks like this:

public final class Example {
    private final String message;

    public Example(String message) {
        this.message = message;
        System.out.println("Message is: " + this.message);
    }

    public String getMessage() {
        return this.message;
    }
}

Multiple init block bytecode:

public final class MultiInitExample {
    private final String name;

    public MultiInitExample(String name) {
        this.name = name;
        System.out.println("First init block: Name is " + this.name);
        System.out.println("Second init block: Name length is " + this.name.length());
    }

    public String getName() {
        return this.name;
    }
}

Real-World Example: Using init in Android

In Android development, init is useful for initializing values that depend on constructor parameters.

Consider a ViewModel:

class MyViewModel(private val repository: Repository) : ViewModel() {
    init {
        println("ViewModel initialized with repository: $repository")
    }
}

Or for a custom view in Jetpack Compose:

class CustomView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null
) : View(context, attrs) {
    init {
        // Read attributes, initialize paint objects, etc.
        println("CustomView initialized")
    }
}

---

Final Thoughts

The init block in Kotlin brings structured initialization, reducing boilerplate and improving readability. It replaces Java’s constructor initialization logic in a more elegant way. Next time you're working on a Kotlin project, try using init for setting up your objects efficiently!

Let me know your thoughts in the comments below—do you use init regularly, or do you prefer other ways of initialization in Kotlin? 🚀

---

---