Star projection for unknown types in Kotlin - Mini Project: Build & Apply

Star Projection for Unknown Types in Kotlin

📖 Scenario: Imagine you are building a library system that can hold collections of different types of items, like books, magazines, or DVDs. Sometimes, you don't know exactly what type of items a collection holds, but you still want to work with it safely.

🎯 Goal: You will create a Kotlin program that uses star projection to handle collections with unknown types. This helps you work with generic types safely when you don't know the exact type inside.

📋 What You'll Learn

Create a generic class called Box that holds a value of any type.

Create a list of Box objects with different types inside.

Use star projection Box<*> to handle the list with unknown types.

Print the contents of each Box safely using star projection.

💡 Why This Matters

🌍 Real World

Star projection helps when working with libraries or APIs where you don't know the exact generic type but still want to use the data safely.

💼 Career

Understanding star projection is important for Kotlin developers working with generics, especially in Android development and library design.

1

Create the generic class Box

Create a generic class called Box with a property value of type T. This class will hold any type of value.

Kotlin

class Box(val value: T) {
    // Your code here
}

Hint

Use class Box<out T>(val value: T) to create a generic class with a value property.

2

Create a list of Box objects with different types

Create a list called boxes that contains Box objects holding these exact values: Box(123), Box("Hello"), and Box(45.6).

Kotlin

class Box(val value: T)

val boxes = listOf(
    // Your code here
)

Hint

Use listOf(Box(123), Box("Hello"), Box(45.6)) to create the list.

3

Use star projection to handle unknown types

Create a variable called unknownBoxes of type List<Box<*>> and assign it the value of boxes. This uses star projection to handle boxes with unknown types.

Kotlin

class Box(val value: T)

val boxes = listOf(Box(123), Box("Hello"), Box(45.6))

val unknownBoxes: List> = boxes
// Your code here

Hint

Use val unknownBoxes: List<Box<*>> = boxes to declare the variable with star projection.

4

Print the contents of each Box safely

Use a for loop with variable box to iterate over unknownBoxes. Inside the loop, print the value property of each box.

Kotlin

class Box(val value: T)

val boxes = listOf(Box(123), Box("Hello"), Box(45.6))

val unknownBoxes: List> = boxes

for (box in unknownBoxes) {
    // Your code here
}

Hint

Use for (box in unknownBoxes) { println(box.value) } to print each value.

Practice

1. What does the star projection * represent in Kotlin generics?

easy

A. A type that can only be used with primitive data types

B. A specific generic type that must be defined explicitly

C. A wildcard that allows writing but restricts reading

D. An unknown generic type that allows safe reading but restricts writing

Solution

1. Step 1: Understand star projection meaning

   The star projection * means an unknown generic type in Kotlin.

2. Step 2: Analyze its usage

   It allows safe reading from generic collections but restricts writing to avoid type errors.

3. Final Answer:

   An unknown generic type that allows safe reading but restricts writing -> Option D

4. Quick Check:

   Star projection = unknown generic type with safe read [OK]

Hint: Star projection means unknown type, safe read only [OK]

Common Mistakes:

• Thinking star projection allows writing to generics
• Confusing star projection with specific generic types
• Assuming star projection only works with primitives

2. Which of the following is the correct syntax to declare a list with star projection in Kotlin?

easy

A. val list: List<Any> = listOf(1, 2, 3)

B. val list: List<*> = listOf(1, 2, 3)

C. val list: List<> = listOf(1, 2, 3)

D. val list: List = listOf(1, 2, 3)

Solution

1. Step 1: Recall star projection syntax

   Star projection uses * inside angle brackets to represent unknown type.

2. Step 2: Check each option

   val list: List<*> = listOf(1, 2, 3) uses List<*> which is correct syntax for star projection.

3. Final Answer:

   val list: List<*> = listOf(1, 2, 3) -> Option B

4. Quick Check:

   Star projection syntax = List<*> [OK]

Hint: Star projection syntax always uses * inside angle brackets [OK]

Common Mistakes:

• Leaving angle brackets empty like List<>
• Using List<Any> which is not star projection
• Confusing star projection with out-projection

3. What will be the output of the following Kotlin code?

fun printFirst(list: List<*>) {
    println(list[0])
}

fun main() {
    val numbers: List<Int> = listOf(10, 20, 30)
    printFirst(numbers)
}

medium

A. 10

B. Compilation error

C. null

D. Runtime exception

Solution

1. Step 1: Understand star projection usage in function

   The function accepts List<*>, meaning unknown generic type, safe to read elements.

2. Step 2: Analyze the call with List<Int>

   Passing List<Int> is valid; reading list[0] returns 10 safely.

3. Final Answer:

   10 -> Option A

4. Quick Check:

   Reading from List<*> returns element safely [OK]

Hint: Reading from List<*> works, writing does not [OK]

Common Mistakes:

• Assuming star projection causes compile error
• Expecting null instead of actual element
• Thinking runtime exception occurs on read

4. Identify the error in the following Kotlin code using star projection:

fun addElement(list: MutableList<*>, element: Any) {
    list.add(element)
}

medium

A. Element type Any is incompatible with list

B. Syntax error in function declaration

C. Cannot add element to MutableList<*> due to unknown type

D. No error, code compiles and runs fine

Solution

1. Step 1: Understand star projection with MutableList

   MutableList<*> means unknown generic type; writing is restricted to avoid type errors.

2. Step 2: Analyze the add operation

   Trying to add element causes compile error because type is unknown and unsafe to write.

3. Final Answer:

   Cannot add element to MutableList<*> due to unknown type -> Option C

4. Quick Check:

   Writing to MutableList<*> causes error [OK]

Hint: Cannot write to star-projected mutable collections [OK]

Common Mistakes:

• Thinking add works with MutableList<*>
• Confusing syntax error with type error
• Assuming Any type is always accepted

5. Given a function that accepts a list with star projection, how can you safely copy elements from List<*> to a MutableList<Any> in Kotlin?

hard

A. Use a loop to cast each element to Any and add to MutableList<Any>

B. Directly assign List<*> to MutableList<Any>

C. Use star projection on both lists

D. Use MutableList<*> instead of MutableList<Any>

Solution

1. Step 1: Understand star projection restrictions

   List<*> allows safe reading but elements are of unknown type, so direct assignment to MutableList<Any> is unsafe.

2. Step 2: Safely copy elements

   Use a loop to read each element and cast to Any before adding to MutableList<Any>, ensuring type safety.

3. Final Answer:

   Use a loop to cast each element to Any and add to MutableList<Any> -> Option A

4. Quick Check:

   Copy with loop and cast = safe transfer [OK]

Hint: Copy elements with loop and cast from List<*> to MutableList<Any> [OK]

Common Mistakes:

• Trying direct assignment between incompatible generic types
• Using star projection on mutable list incorrectly
• Ignoring type casting when copying elements