Kotlin Init vs Constructor: Differences With Practical Examples

Kotlin, a powerful and modern programming language, brings unique features to object-oriented programming. One of the most common questions among developers is understanding the difference between the init block and the constructor in Kotlin. These two constructs play crucial roles in object initialization but function differently.

In this article, you'll learn the differences between the Kotlin init block and the Kotlin constructor, complete with examples, to help you confidently use them in your Kotlin projects.

What is a Constructor in Kotlin?

A constructor in Kotlin is a special member function used to initialize an object when a class is created. Kotlin provides two types of constructors: the primary constructor and the secondary constructor. These constructors differ in syntax and purpose.

The Primary Constructor

The primary constructor is declared as part of the class name itself and is often used for initializing class properties. It’s concise and straightforward, making it an excellent choice for most scenarios.

Syntax of a Primary Constructor

Copy
1class Person(val name: String, var age: Int)

In this Person class, the primary constructor initializes two properties, name and age. These are declared inside the constructor as parameters and mapped directly to the class properties.

Default Values in a Primary Constructor

You can assign default values to constructor parameters, simplifying object creation:

Copy
1class Person(val name: String = "Unknown", var age: Int = 0)

Here, the default values "Unknown" and 0 are used if no specific values are provided during object creation.

The Secondary Constructor

A secondary constructor provides additional ways to instantiate a class. Unlike the primary constructor, it’s defined inside the class using the constructor keyword.

Syntax of a Secondary Constructor

Copy
1class Person {
2    var name: String
3    var age: Int
4
5    constructor(name: String, age: Int) {
6        this.name = name
7        this.age = age
8    }
9}

This secondary constructor explicitly initializes the properties name and age.

Combining Primary and Secondary Constructors

You can use both the primary constructor and secondary constructors in the same class:

Copy
1class Person(val name: String) {
2    var age: Int = 0
3
4    constructor(name: String, age: Int) : this(name) {
5        this.age = age
6    }
7}

In this example, the secondary constructor provides an additional way to initialize the age property.

What is the Init Block in Kotlin?

The init block is a special block of code used to execute initialization logic immediately after the primary constructor runs. It’s especially useful when you need to execute custom logic that depends on the constructor parameters.

Syntax of the Init Block

Copy
1class Person(val name: String, var age: Int) {
2    init {
3        println("Person initialized with name: $name and age: $age")
4    }
5}

In this example, the init block executes automatically during object creation. It provides a way to add additional initialization code without defining extra functions.

Multiple Init Blocks

You can define multiple init blocks in a single class. These blocks execute in the same order as they appear in the class.

Copy
1class Person(val name: String, var age: Int) {
2    init {
3        println("First init block: Name is $name")
4    }
5    init {
6        println("Second init block: Age is $age")
7    }
8}

Key Differences Between Init Block and Constructor

Advanced Examples of Init Block and Constructors

Using Init Block for Custom Initialization

Suppose you want to validate the age property during initialization:

Copy
1class Person(val name: String, var age: Int) {
2    init {
3        require(age >= 0) { "Age must be non-negative" }
4    }
5}

Here, the init block ensures that age is a valid value.

Combining Init Block with Secondary Constructors

You can also combine the init block with two secondary constructors to handle complex scenarios:

Copy
1class Person {
2    var name: String = "Unknown"
3    var age: Int = 0
4
5    init {
6        println("First init block: Default initialization")
7    }
8
9    constructor(name: String) {
10        this.name = name
11        println("Secondary constructor with single parameter")
12    }
13
14    constructor(name: String, age: Int) : this(name) {
15        this.age = age
16        println("Secondary constructor with two parameters")
17    }
18}

Property Initializers in Kotlin

You can use property initializers alongside the init block for better clarity:

Copy
1class Person(val name: String) {
2    var age: Int = 0
3    init {
4        println("Person initialized with name $name")
5    }
6}

Final Thoughts!

Understanding the difference between the Kotlin init block and the Kotlin constructor is essential for mastering Kotlin. The primary constructor and secondary constructors provide flexible ways to instantiate objects, while the init block lets you add custom initialization logic. By leveraging these tools effectively, you can write concise, robust, and maintainable Kotlin code.