Kotlin : 100 Interview Questions and Answers PART13

61. What is the difference between init and constructor in Kotlin?

62. The concept of generics in Kotlin.

Generics in Kotlin allow you to write type-safe and reusable code that can work with any data type, while still retaining full compile-time type checking.

Why Use Generics?

• Type safety: Catch type errors at compile time
• Code reusability: Write one class or function that works with different types
• Cleaner APIs: Avoid duplication

Basic Syntax:

class Box<T>(val value: T) {
    fun get(): T = value
}

Here, T is a type parameter, which can be replaced with any actual type (e.g., Box<Int>, Box<String>).

Generic Functions

fun <T> printList(items: List<T>) {
    for (item in items) println(item)
}

printList(listOf(1, 2, 3))
printList(listOf("a", "b", "c"))

*Importants:

63. Difference Between Invariance, Covariance, and Contravariance in Kotlin Generics

• Covariant (out) = You can get T out safely, but you cannot put T in.
• Contravariant (in) = You can put T in safely, but you cannot get T out (except as Any?).
• Invariant = You can put and get T, but no subtype substitution allowed.

Invariance

• 1. The default behavior of Kotlin generics.
• 2. Type Generic<A> is not considered a subtype or supertype of Generic<B> even if A is subtype or supertype of B.
• 3. You cannot substitute Generic<Child> where Generic<Parent> is expected.

Example:

val listOfStrings: MutableList<String> = mutableListOf()
val listOfAny: MutableList<Any> = listOfStrings // ❌ Compilation error!

Covariance (out keyword)

• 1. Allows a generic type to preserve the subtype relationship.
• 2. Generic<Child> can be used where Generic<Parent> is expected.
• 3. Use when the generic type is only produced (output), never consumed (input).
• 4. You declare covariance with out modifier.

Example:

interface Producer<out T> {
    fun produce(): T
}

val producerString: Producer<String> = object : Producer<String> {
    override fun produce() = "Hello"
}

val producerAny: Producer<Any> = producerString // ✅ Allowed because of covariance

Contravariance (in keyword)

• 1. Allows a generic type to reverse the subtype relationship.
• 2. Generic<Parent> can be used where Generic<Child> is expected.
• 3. Use when the generic type is only consumed (input), never produced (output).
• 4. You declare contravariance with in modifier.

Example:

interface Consumer<in T> {
    fun consume(item: T)
}

val consumerAny: Consumer<Any> = object : Consumer<Any> {
    override fun consume(item: Any) {
        println(item)
    }
}

val consumerString: Consumer<String> = consumerAny // ✅ Allowed because of contravariance

64. The concept of typealias in Kotlin.

typealias in Kotlin allows you to give an alternative name to an existing type. It can improve code readability, simplify long type declarations, or create more meaningful names for complex types.

It does not create a new type — it's just a shortcut or an alias to an existing type.

Syntax

typealias NewName = ExistingType

Why use typealias?

• 1. Simplify long or complex generic types
• 2. Provide more meaningful names for function types
• 3. Increase code clarity and maintainability

Examples

Alias for a generic type

typealias UserMap = Map<String, User>

Now, instead of writing Map<String, User>, you can write:

val users: UserMap = mapOf("id1" to User("Alice"), "id2" to User("Bob"))

Notes

• 1. typealias does not create new types, so it’s not useful for type safety — just naming.
• 2. Helpful when working with complex functional types or nested generics.
• 3. Compatible with classes, interfaces, function types, generics, etc.

65. The concept of tail recursion in Kotlin

Tail recursion is a special form of recursion where the recursive call is the last operation in a function. This allows the compiler to optimize the recursion by reusing the same stack frame instead of creating a new one for each call — preventing stack overflow and improving performance.

A function is tail-recursive if:

• 1. The recursive call is the last statement executed in the function
• 2. Nothing is done after the recursive call returns

Tail Recursion in Kotlin

Kotlin supports tail recursion via the tailrec modifier.

If a function is marked tailrec and is properly tail-recursive, the compiler will optimize it into a loop internally.

Example: Factorial Using Tail Recursion

tailrec fun factorial(n: Int, accumulator: Long = 1): Long {
    return if (n <= 1) accumulator
    else factorial(n - 1, accumulator * n)  // recursive call is last operation
}

Calling:

println(factorial(5))  // Output: 120

Why use tailrec?

1. Without tailrec, recursive calls can cause stack overflow for large inputs.

2. With tailrec, Kotlin transforms recursion into a loop under the hood, so it’s safe for large input values.

When Tail Recursion Doesn't Work

• 1. If recursive call is not last (e.g., you do some computation after the recursive call)
• 2. If you have multiple recursive calls
• 3. If your recursive call’s result is modified before returning