In software development, constructors play an essential role in object creation, especially when initializing objects with different properties. However, there’s a common issue known as the Telescoping Constructor Anti-pattern, which often arises when dealing with multiple constructor parameters. This anti-pattern can make your code difficult to read, maintain, and scale, leading to confusion and error-prone behavior.

In this blog, we’ll explore the Telescoping Constructor Anti-pattern, why it occurs, and how to avoid it in Kotlin. We will also cover better alternatives to improve code readability and maintainability.

What is the Telescoping Constructor Anti-pattern?

The Telescoping Constructor Anti-pattern occurs when a class provides multiple constructors that vary by the number of parameters. These constructors build on one another by adding optional parameters, creating a ‘telescoping’ effect. This results in constructors that become increasingly long and complex, making the class difficult to understand and maintain.

While this approach works, it can lead to confusion and make the code difficult to read and maintain. This anti-pattern is more common in languages without default parameters, but it can still appear in Kotlin, especially if we stick to old habits from other languages like Java.

Example of Telescoping Constructor

Let’s imagine we have a Person class with multiple fields: name, age, address, and phoneNumber. We may want to allow users to create a Person object by providing only a name, or perhaps a name and age, or all the fields.

One way to handle this would be to create multiple constructors, each one adding more parameters than the previous:

class Person {
    var name: String
    var age: Int
    var address: String
    var phoneNumber: String

    // Constructor with only name
    constructor(name: String) {
        this.name = name
        this.age = 0
        this.address = ""
        this.phoneNumber = ""
    }

    // Constructor with name and age
    constructor(name: String, age: Int) : this(name) {
        this.age = age
    }

    // Constructor with name, age, and address
    constructor(name: String, age: Int, address: String) : this(name, age) {
        this.address = address
    }

    // Constructor with all parameters
    constructor(name: String, age: Int, address: String, phoneNumber: String) : this(name, age, address) {
        this.phoneNumber = phoneNumber
    }
}

At first glance, this might seem reasonable, but as the number of parameters increases, the number of constructors multiplies, leading to a “telescoping” effect. This is both cumbersome to maintain and confusing for anyone trying to use the class.

Why is this a Problem?

There are several issues with the telescoping constructor approach:

1. Code Duplication: Each constructor builds on the previous one, but they duplicate a lot of logic. This makes the code harder to maintain and more error-prone.
2. Lack of Readability: As the number of constructors grows, it becomes harder to keep track of which parameters are optional and which are required. This reduces the clarity of the code.
3. Hard to Scale: If you need to add more fields to the class, you’ll have to keep adding more constructors, making the problem worse over time.

How Kotlin Can Help Avoid the Telescoping Constructor Anti-pattern

Kotlin provides several features that allow you to avoid the telescoping constructor anti-pattern entirely. These features include:

• Default Parameters
• Named Arguments
• apply Function
• Builder Pattern

Let’s walk through these options one by one.

Default Parameters

In Kotlin, we can assign default values to function parameters, including constructors. This eliminates the need for multiple constructors.

Refactored Example Using Default Parameters

class Person(
    var name: String,
    var age: Int = 0,
    var address: String = "",
    var phoneNumber: String = ""
)

With default values, the class can be instantiated in multiple ways without creating multiple constructors:

val person1 = Person("Amol")
val person2 = Person("Baban", 25)
val person3 = Person("Chetan", 30, "123 Main St")
val person4 = Person("Dinesh", 35, "456 Back St", "123-456-7890")

This approach is simple, clean, and avoids duplication. You no longer need multiple constructors, and it’s much easier to add new fields to the class.

Named Arguments

Kotlin also supports named arguments, which makes it clear what each parameter represents. This is particularly helpful when a class has several parameters, making the code more readable.

Example

val person = Person(name = "Eknath", age = 28, address = "789 Pune St")

With named arguments, we can skip parameters we don’t need to specify, further reducing the need for multiple constructors.

Using the apply Function for Fluent Initialization

Another feature of Kotlin is the apply function, which allows you to initialize an object in a more readable, fluent manner. This is useful when you want to initialize an object and set various properties in one block of code.

Example with apply:

val person = Person("Farhan").apply {
    age = 40
    address = "123 Old Delhi St"
    phoneNumber = "987-654-3210"
}

With apply, you can set properties in a concise and readable way, without needing to pass them all in the constructor.

The Builder Pattern (When the Object Becomes More Complex)

For more complex cases where a class has many parameters and their combinations are non-trivial, using the Builder Pattern can be a good solution. This pattern allows the creation of objects step by step, without needing to overload constructors.

Example of Builder Pattern

class Person private constructor(
    var name: String,
    var age: Int,
    var address: String,
    var phoneNumber: String
) {
    class Builder {
        private var name: String = ""
        private var age: Int = 0
        private var address: String = ""
        private var phoneNumber: String = ""

        fun setName(name: String) = apply { this.name = name }
        fun setAge(age: Int) = apply { this.age = age }
        fun setAddress(address: String) = apply { this.address = address }
        fun setPhoneNumber(phoneNumber: String) = apply { this.phoneNumber = phoneNumber }

        fun build() = Person(name, age, address, phoneNumber)
    }
}

Usage of the builder pattern:

val person = Person.Builder()
    .setName("Ganesh")
    .setAge(42)
    .setAddress("567 Temple St")
    .setPhoneNumber("555-1234")
    .build()

This approach is particularly useful when you have many optional parameters or when the parameters are interdependent.

Why is the Telescoping Constructor Anti-Pattern Bad?

1. Readability: Long, complex constructors can be difficult to read and understand, especially for new developers or when revisiting the code after a long time.
2. Maintainability: Adding new required parameters to a telescoping constructor requires updating all existing constructors, which can be time-consuming and error-prone.
3. Flexibility: The telescoping constructor pattern can limit flexibility, as it forces clients to provide all required parameters, even if they don’t need them.

Conclusion

The Telescoping Constructor Anti-pattern can make code difficult to maintain and read, especially as the number of parameters grows. Kotlin provides several powerful features to help you avoid this anti-pattern:

• Default Parameters allow you to define default values directly in the constructor.
• Named Arguments improve readability when calling constructors with multiple parameters.
• apply function enables fluent initialization of object properties.
• Builder Pattern is useful for more complex object creation scenarios.

By leveraging these Kotlin features, you can write more maintainable and readable code, avoid constructor overloads, and eliminate the need for the telescoping constructor anti-pattern.