Kotlin Constructors

University

Learn Kotlin

Kotlin Constructors

Ekaterina Khudikova

Contributed on

September 26, 2024

Introduction to Constructors

Constructors in Kotlin are used to initialize new instances of a class, allowing the setup of an object with predefined values or parameters. There are two types of constructors in Kotlin:

Primary Constructor
Secondary Constructor

The primary constructor is declared directly in the class header. It follows the class name and can have a list of parameters. These parameters become properties of the class automatically, so there's no need to explicitly declare them.

The secondary constructor is defined within the body of the class. It provides an alternative way to initialize objects with different sets of arguments. The keyword constructor is used, followed by a list of parameters. All secondary constructors must delegate to the primary constructor using the this keyword.

Definition of Constructors

Constructors are special functions in Kotlin that create and initialize new instances of a class. They set up the initial state of an object.

Primary Constructor

The primary constructor is part of the class declaration. It sets up the initial state of the object by accepting parameter values that initialize the object's properties.

Secondary Constructor

Secondary constructors provide an alternative way to initialize an object. They can be defined within the class body, prefixed with the constructor keyword, and are used when additional ways of initializing an object are needed.

Importance of Constructors in Programming Languages

Constructors play a key role in initializing an object's state. When an object is created, constructors ensure it is properly set up with its values and attributes. This ensures that objects are in a consistent and valid state from the start, reducing potential errors.

Constructors can also enforce initialization rules, set default values, and perform calculations or validations. They support code reusability by allowing multiple instances of objects with different states, encapsulating the initialization process within the object itself.

Purpose of Constructors in Kotlin

In Kotlin, constructors initialize objects and set their initial state. They prepare an object for use by assigning values to its properties or performing necessary setup tasks. Kotlin offers flexibility in object creation with primary constructors, secondary constructors, and init blocks.

Types of Constructors

Primary Constructor

The primary constructor is defined in the class header, immediately after the class name. It declares and initializes the properties of the class. Default argument values can be included if needed.

Secondary Constructors

Secondary constructors are optional and are declared within the class body. They do not define properties but provide additional ways to initialize the class. Different parameter lists allow different ways of creating instances. However, they must delegate to the primary constructor using this.

Primary Constructor

The primary constructor is a concise way to declare and define properties for a class. It is declared in the class header and may include parameters. This constructor simplifies code by removing the need for separate initialization functions or blocks.

Example

class MyClass(val param1: String, val param2: Int = 0)

In the above example, MyClass has a primary constructor that initializes param1 and param2 properties. The class can be instantiated using this constructor.

Secondary Constructors

Secondary constructors allow multiple ways to initialize an object. They are useful for subclasses that require additional logic or default values.

Syntax

constructor(parameters)

A secondary constructor uses the constructor keyword, followed by a parameter list. Unlike the primary constructor, it doesn't declare properties and must delegate to the primary constructor.

Default Constructor

A default constructor is automatically called when an object is created without any arguments. It initializes the object with default values or necessary setup.

Class Header and Constructor Keyword

The class header serves as the blueprint for creating instances. The primary constructor is defined within the class header using parentheses, specifying properties and their initialization. The constructor keyword is used for secondary constructors to provide alternative initialization.

Syntax for Declaring Primary Constructor in Class Header

To declare a primary constructor, include the constructor parameters directly after the class name. The constructor keyword is optional unless access modifiers or annotations are applied.

class MyClass(param1: String, param2: Int)

If no secondary constructors are defined, the primary constructor is considered a default primary constructor.

Using the "constructor" Keyword in Primary Constructor Declaration

In some cases, the constructor keyword is explicitly used to enforce conditions or default values on properties. This enhances readability and allows customization during object creation.

Initialization Code and Init Blocks

The init block in Kotlin is used for initializing properties of a class. It is executed when an object of the class is created and is placed within the class body. The block is used to assign values to properties or perform setup tasks.

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

The init block is executed sequentially in the order it appears in the class body.

Initializing Properties Using Init Blocks

To initialize properties with init blocks:

1. Declare properties within the class.

2. Use init to assign values or perform initialization tasks.

class Person {
    var name: String
    var age: Int
    
    init {
        name = "John Doe"
        age = 30
    }
}

Multiple init blocks are allowed and are executed in order.

Difference Between Init Blocks and Primary Constructor Initialization Code

Init blocks and primary constructor initialization code both set up properties in a class. However, init blocks provide flexibility for complex initialization, while the primary constructor provides a straightforward way to initialize properties directly.

Default Values and Property Initializers

Kotlin constructors can have default values for parameters, simplifying object creation. Property initializers assign default values directly to properties. This reduces the need for multiple constructors.