Constructors and Init Blocks in Kotlin

In Kotlin, constructors and init blocks provide a structured way to initialize objects and perform setup tasks. Kotlin simplifies object creation by supporting primary and secondary constructors along with initialization blocks.

1. Why Constructors and Init Blocks Matter

Constructors and init blocks help in setting up the initial state of objects:

• Encapsulation: Ensure that objects are always initialized in a valid state.
• Code Organization: Keeps initialization logic within the class, making it easier to maintain.
• Flexibility: Allows complex initialization and input validation during object creation.

2. Primary Constructor

The primary constructor is a concise way to initialize a class. It is defined in the class header:

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

  

2.1 Using Init Blocks

The init block is executed when the object is created and can contain initialization logic:

class Person(val name: String, var age: Int) {
    init {
        println("Person object created: $name, Age: $age") 
        
        
    }
}
  

Example:

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

Output:

Person object created: Alice, Age: 25
  

3. Secondary Constructor

Secondary constructors allow multiple ways to initialize a class. They are defined inside the class body using the constructor keyword:

class Person {
    var name: String
    var age: Int

    constructor(name: String) {
        this.name = name
        this.age = 0
        
    }

    constructor(name: String, age: Int) {
        this.name = name
        this.age = age
        
    }
}
  

Example:

fun main() {
    val person1 = Person("Bob") // Uses first secondary constructor
    val person2 = Person("Charlie", 30) // Uses second secondary constructor
    println("${person1.name}, ${person1.age}") // Bob, 0
    println("${person2.name}, ${person2.age}") // Charlie, 30
}
  

4. Combining Init Blocks and Constructors

You can combine primary constructors, secondary constructors, and init blocks to handle complex initialization:

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

    init {
        println("Init block: $name, Age: $age")
        if(age < 0) age = 0
        
    }

    constructor(name: String) : this(name, 0) {
        println("Secondary constructor called for $name")
        
    }
}
  

Example:

fun main() {
    val person1 = Person("David", 28) // Primary constructor called
    val person2 = Person("Eve")       // Secondary constructor called
}
  

Output:

Init block: David, Age: 28
Init block: Eve, Age: 0
Secondary constructor called for Eve
  

5. Execution Order of Constructors and Init Blocks

Here’s the order when an object is created:

1. If you call a secondary constructor that delegates to a primary constructor, the primary constructor runs first.
2. Then, all init blocks execute in the order they appear in the class.
3. Finally, the code inside the secondary constructor runs.

If you don’t delegate to the primary constructor, the secondary constructor runs directly and init blocks are not executed.

6. Technical Interview Questions

• What is the difference between primary and secondary constructors?
  Primary constructors are declared in the class header, while secondary constructors are inside the class body.
• When is the init block executed?
  The init block runs immediately after the primary constructor is called, before any secondary constructor logic.
• Why do we use : this(...) in secondary constructors?
  It calls the primary constructor, ensuring all common initialization logic (including init blocks) executes, reducing code duplication.
• Can a class have multiple secondary constructors?
  Yes, allowing multiple ways to create objects with different input parameters.
• Can a class have multiple init blocks?
  Yes, init blocks are executed in the order they appear in the class.
• Why would you need a secondary constructor instead of default parameters?
  Secondary constructors are useful when you need completely different initialization logic that can't be handled with default values alone.
• If a secondary constructor does not call the primary constructor, what happens?
  Init blocks are skipped, and you are responsible for initializing all properties inside the secondary constructor.
• What is the execution order when a secondary constructor calls the primary constructor?
  1. Primary constructor runs first.
  2. Init blocks execute in order.
  3. Secondary constructor code executes last.
• What happens if you don’t define any constructor in a Kotlin or Java class?
  If you don’t explicitly define a constructor, the compiler automatically provides a default constructor.
  
  
  • In Kotlin — the compiler generates a primary constructor without parameters.
  • In Java — the compiler generates a no-argument default constructor only if no constructor is declared.
  Behavior:
  - All properties are initialized with their default values (e.g., 0 for Int, false for Boolean, and null for nullable references).
  - The object can still be created using the default constructor.
  - No initialization logic (like init blocks) is run unless explicitly defined.
  
  Kotlin Example:
  

  
  class Person {
      var name: String? = null
      var age: Int = 0
  }
  
  fun main() {
      val person = Person() // Uses compiler-generated default constructor
      println("Name: ${person.name}, Age: ${person.age}")
  }
      

  Output:
  

  
  Name: null, Age: 0
      

  Explanation:
  - Kotlin automatically provides a public no-argument constructor.
  - The properties name and age are initialized with default values because no constructor overrides them.
  
  Java Equivalent:
  

  
  public class Person {
      String name;
      int age;
      
      // Default constructor is auto-generated by compiler
  }
  
  public class Main {
      public static void main(String[] args) {
          Person p = new Person(); // Uses compiler-provided default constructor
          System.out.println("Name: " + p.name + ", Age: " + p.age);
      }
  }
      

  Output:
  

  
  Name: null, Age: 0
      

7. Key Takeaways

• Primary constructors provide a concise way to initialize properties.
• Init blocks allow execution of initialization logic and validation.
• Secondary constructors provide flexibility for multiple initialization paths.
• Calling the primary constructor from a secondary constructor ensures consistency and avoids code duplication.
• Combining init blocks and constructors helps in managing complex initialization logic cleanly.
• Understanding execution order is crucial for writing predictable initialization logic.