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

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:

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

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:

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

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.

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

Feature	Primary Constructor	Secondary Constructor	Init Block
Syntax	Defined in the class name	Defined using the constructor keyword	Defined with the init keyword
Purpose	Initializes class properties	Provides additional constructors	Executes additional initialization
Execution	Called automatically during instantiation	Must be explicitly invoked	Executes immediately after the primary constructor
Supports Default Values	Yes	Yes	No
Location	Part of the class header	Inside the class body	Inside the class body

Advanced Examples of Init Block and Constructors

Using Init Block for Custom Initialization

Suppose you want to validate the age property during initialization:

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:

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:

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.

Short on time? Speed things up with DhiWise!

Tired of manually designing screens, coding on weekends, and technical debt? Let DhiWise handle it for you!

You can build an e-commerce store, healthcare app, portfolio, blogging website, social media or admin panel right away. Use our library of 40+ pre-built free templates to create your first application using DhiWise.