Why generics provide type safety in Kotlin - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of generic list usage

What is the output of this Kotlin code that uses generics to ensure type safety?

Kotlin

fun main() {
    val list: List<String> = listOf("apple", "banana", "cherry")
    println(list[1])
}

A apple

B banana

C cherry

D IndexOutOfBoundsException

💡 Hint

Look at the index used to access the list element.

The list is a List containing three fruits. Accessing index 1 returns the second element, "banana".

🧠 Conceptual

intermediate

Why generics prevent runtime errors

Why do generics in Kotlin help prevent runtime ClassCastException errors?

A Because generics check types at compile time, preventing wrong types from being assigned.

B Because generics convert all types to String automatically.

C Because generics delay type checking until runtime.

D Because generics allow any type without restrictions.

💡 Hint

Think about when type errors are caught in generic code.

Generics enforce type constraints during compilation, so wrong types cause errors before running the program.

🔧 Debug

advanced

Identify the type safety violation

Which option shows code that violates type safety despite using generics?

Kotlin

fun main() {
    val list: MutableList<Any> = mutableListOf("hello", 123)
    val strings: MutableList<String> = list as MutableList<String>
    strings.add("world")
    println(strings)
}

A The println statement is incorrect syntax.

B The list declaration is missing type parameters.

C The cast from MutableList<Any> to MutableList<String> is unsafe and causes runtime errors.

D The add method cannot add strings to a MutableList.

💡 Hint

Casting generic collections unsafely can break type safety.

Casting MutableList to MutableList bypasses compile-time checks and can cause ClassCastException at runtime.

📝 Syntax

advanced

Correct generic function syntax

Which option correctly declares a generic function in Kotlin that returns the first element of a list?

A fun firstElement<T>(list: List<T>): T = list[0]

B fun <T> firstElement(list: List<T>): T { return list.get(1) }

C fun firstElement(list: List): T = list[0]

D fun <T> firstElement(list: List<T>): T = list[0]

💡 Hint

Generic type parameters go before the function name.

Option D correctly places before the function name and returns the first element at index 0.

🚀 Application

expert

Determine the output of generic variance

What is the output of this Kotlin code demonstrating generic variance with 'out' keyword?

Kotlin

open class Animal
class Dog: Animal()

fun printAnimals(animals: List<Animal>) {
    println("Number of animals: ${animals.size}")
}

fun main() {
    val dogs: List<Dog> = listOf(Dog(), Dog())
    printAnimals(dogs)
}

A Number of animals: 2

B Runtime ClassCastException

C Number of animals: 0

D Type mismatch error at compile time

💡 Hint

Kotlin's List is covariant with 'out' keyword, allowing List to be passed as List.

Because List is declared as List, List can be used where List is expected, so the function prints the size 2.