Type constraints with upper bounds in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of generic function with upper bound

What is the output of this Kotlin code snippet?

Kotlin

open class Animal(val name: String) {
    fun sound() = "Some sound"
}

class Dog(name: String) : Animal(name) {
    fun bark() = "Woof"
}

fun <T : Animal> makeSound(animal: T): String {
    return animal.sound()
}

fun main() {
    val dog = Dog("Buddy")
    println(makeSound(dog))
}

A Woof

B Runtime error

C Some sound

D Compilation error due to type constraint

💡 Hint

Think about which method is called inside makeSound and what is available in the upper bound type.

The function makeSound accepts any type T that extends Animal. Inside, it calls animal.sound(), which is defined in Animal. Although Dog has bark(), makeSound only calls sound(), so output is "Some sound".

❓ Predict Output

intermediate

Result of generic function with multiple upper bounds

What will this Kotlin code print?

Kotlin

interface Runner {
    fun run() = "Running"
}

open class Animal(val name: String)

class Dog(name: String) : Animal(name), Runner

fun <T> action(animal: T) where T : Animal, T : Runner {
    println(animal.run())
}

fun main() {
    val dog = Dog("Max")
    action(dog)
}

A Animal's name printed

B Compilation error due to multiple upper bounds

C Runtime exception

D Running

💡 Hint

Check how multiple upper bounds allow calling methods from both types.

The generic function action requires T to be both Animal and Runner. Dog satisfies both. The call animal.run() uses Runner's method, so output is "Running".

🔧 Debug

advanced

Identify the compilation error in generic function

Why does this Kotlin code fail to compile?

Kotlin

open class Animal

class Dog : Animal()

fun <T> printName(animal: T) where T : Animal {
    println(animal.name)
}

fun main() {
    val dog = Dog()
    printName(dog)
}

A Property 'name' is not defined in Animal, causing compilation error

B Dog does not extend Animal properly

C Generic constraint syntax is incorrect

D No compilation error, code runs fine

💡 Hint

Check if the property 'name' exists in the upper bound type Animal.

The Animal class does not have a 'name' property, so accessing animal.name causes a compilation error.

📝 Syntax

advanced

Correct syntax for generic function with upper bound

Which option shows the correct syntax for a generic function with an upper bound Animal?

A fun <T : Animal> doSomething(animal: T) { println(animal) }

B fun <T Animal> doSomething(animal: T) { println(animal) }

C fun <T> doSomething(animal: T : Animal) { println(animal) }

D fun <T> doSomething(animal: T) where T Animal { println(animal) }

💡 Hint

Recall the syntax for declaring upper bounds in Kotlin generics.

Option A correctly uses the syntax to specify that T must be a subtype of Animal.

🚀 Application

expert

Determine the output of complex generic constraints

What is the output of this Kotlin program?

Kotlin

open class Vehicle(val brand: String) {
    open fun info() = "Vehicle brand: $brand"
}

interface Electric {
    fun batteryInfo() = "Battery full"
}

class Tesla(brand: String) : Vehicle(brand), Electric {
    override fun info() = "Tesla brand: $brand"
}

fun <T> printDetails(item: T) where T : Vehicle, T : Electric {
    println(item.info())
    println(item.batteryInfo())
}

fun main() {
    val myCar = Tesla("Model S")
    printDetails(myCar)
}

A Compilation error due to conflicting methods

B

Tesla brand: Model S
Battery full

C

Vehicle brand: Model S
Battery full

D Runtime error due to interface method

💡 Hint

Check which info() method is called and how multiple upper bounds work.

The generic function requires T to be Vehicle and Electric. Tesla overrides info(), so item.info() calls Tesla's version. batteryInfo() comes from Electric. Output is two lines: Tesla brand: Model S and Battery full.