Generic class declaration in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple generic class usage

What is the output of this Kotlin code that uses a generic class?

Kotlin

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

fun main() {
    val box = Box(123)
    println(box.getValue())
}

A 123

B Box@<hashcode>

C Compilation error

D null

💡 Hint

Look at how the generic class stores and returns the value.

The generic class Box stores the value 123 of type Int. The getValue() method returns this value, so the output is 123.

❓ Predict Output

intermediate

Output with generic class and type inference

What will this Kotlin program print when using a generic class with type inference?

Kotlin

class Container<T>(val item: T) {
    fun describe(): String = "Item is: $item"
}

fun main() {
    val c = Container("Hello")
    println(c.describe())
}

A Compilation error due to missing type

B Item is: Container@<hashcode>

C Item is: Hello

D Item is: null

💡 Hint

The generic type is inferred from the constructor argument.

The Container class holds a String "Hello". The describe() method returns the string with the item included, so it prints "Item is: Hello".

🧠 Conceptual

advanced

Understanding generic type constraints

Which option correctly declares a generic class in Kotlin that only accepts types which implement the Comparable interface?

A class Sortable<T>(val item: T) where T : Comparable<T>

B class Sortable<T>(val item: T) where T : Comparable

C class Sortable<T : Comparable>(val item: T)

D class Sortable<T : Comparable<T>>(val item: T)

💡 Hint

Look for the correct syntax for generic constraints in Kotlin.

Option D correctly uses the syntax T : Comparable to constrain T to types that implement Comparable of themselves. Option D is valid Kotlin syntax but less idiomatic here; the 'where' clause is typically used for multiple constraints. Options B and C have syntax errors.

❓ Predict Output

advanced

Output of generic class with nullable type

What is the output of this Kotlin code using a generic class with a nullable type parameter?

Kotlin

class Wrapper<T>(val value: T?) {
    fun isNull(): Boolean = value == null
}

fun main() {
    val w = Wrapper<String>(null)
    println(w.isNull())
}

A true

B false

C Compilation error due to null value

D NullPointerException at runtime

💡 Hint

Check how the nullable type is handled in the class.

The Wrapper class accepts a nullable type T?. The value is null, so isNull() returns true and prints true.

🔧 Debug

expert

Identify the error in this generic class declaration

What error does this Kotlin code produce?

Kotlin

class Pair<T, U>(val first: T, val second: U) {
    fun swap(): Pair<U, T> {
        return Pair(second, first)
    }
}

fun main() {
    val p = Pair(1, "one")
    val swapped = p.swap()
    println("${swapped.first}, ${swapped.second}")
}

A Compilation error: unresolved reference to Pair in swap()

B Output: one, 1

C Runtime error: StackOverflowError

D Compilation error: recursive call in constructor

💡 Hint

Constructor calls using the class name are valid inside class methods in Kotlin.

The code compiles successfully. The swap() method creates a new Pair instance using Pair(second, first), where the types are inferred correctly from the return type and arguments. The program prints "one, 1".