Generic class declaration in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a generic class named Box.

Kotlin

class Box<[1]> {
    var value: T? = null
}

Drag options to blanks, or click blank then click option'

AT

BInt

CString

DAny

Attempts:

3 left

💡 Hint

Common Mistakes

Using a concrete type like Int instead of a generic type parameter.

Forgetting the angle brackets <> around the generic type.

The generic type parameter is declared inside angle brackets after the class name. Here, T is the placeholder for any type.

2fill in blank

medium

Complete the code to create an instance of the generic class Box with type String.

Kotlin

val box: Box<[1]> = Box()

Drag options to blanks, or click blank then click option'

AInt

BString

CDouble

DBoolean

Attempts:

3 left

💡 Hint

Common Mistakes

Using the generic type parameter T instead of a concrete type.

Omitting the type argument when creating the instance.

To create a Box that holds Strings, specify String as the type argument.

3fill in blank

hard

Fix the error in the generic class declaration by completing the blank.

Kotlin

class Container<[1]> {
    fun getValue(): T? = null
}

Drag options to blanks, or click blank then click option'

AData

Bvalue

CT

DType

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name instead of a type parameter.

Mismatch between the declared type parameter and its usage.

The generic type parameter must be declared as T to match its usage inside the class.

4fill in blank

hard

Fill both blanks to declare a generic class Pair with two type parameters.

Kotlin

class Pair<[1], [2]> {
    var first: A? = null
    var second: B? = null
}

Drag options to blanks, or click blank then click option'

AA

BT

CB

DK

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same letter for both type parameters.

Mismatch between type parameter names and property types.

The class uses two generic type parameters named A and B to represent the types of the two values.

5fill in blank

hard

Fill all three blanks to declare a generic class Triple with three type parameters and properties.

Kotlin

class Triple<[1], [2], [3]> {
    var first: X? = null
    var second: Y? = null
    var third: Z? = null
}

Drag options to blanks, or click blank then click option'

AX

BY

CZ

DT

Attempts:

3 left

💡 Hint

Common Mistakes

Using fewer or duplicate type parameters.

Mismatch between type parameters and property types.

The class declares three generic type parameters X, Y, and Z matching the property types.

Practice

1. What is the purpose of declaring a generic class in Kotlin using <T>?

easy

A. To restrict the class to only work with integers

B. To allow the class to work with any data type without rewriting code

C. To make the class abstract

D. To create a singleton class

Solution

1. Step 1: Understand generic class declaration

   Declaring a generic class with <T> means the class can accept any type as a parameter.

2. Step 2: Identify the benefit

   This allows the class to be flexible and reusable for different data types without rewriting the code.

3. Final Answer:

   To allow the class to work with any data type without rewriting code -> Option B

4. Quick Check:

   Generics = Flexible types [OK]

Hint: Generics mean 'any type' for flexible classes [OK]

Common Mistakes:

• Thinking generics restrict types instead of generalizing
• Confusing generics with abstract classes
• Assuming generics create singletons

2. Which of the following is the correct syntax to declare a generic class named Box in Kotlin?

easy

A. class Box<T>;

B. class Box[T] { }

C. class Box<T> { }

D. class Box {<T>}

Solution

1. Step 1: Recall Kotlin generic syntax

   Kotlin uses angle brackets <> to declare generics after the class name.

2. Step 2: Check each option

   Only class Box<T> { } is correct, using angle brackets after the class name. The other options use semicolon after <T>, square brackets, or place <T> inside the braces.

3. Final Answer:

   class Box<T> { } -> Option C

4. Quick Check:

   Generics use <> brackets [OK]

Hint: Use angle brackets <T> after class name for generics [OK]

Common Mistakes:

• Using square brackets [] instead of angle brackets
• Adding semicolon after class declaration
• Placing <T> inside curly braces

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

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

fun main() {
    val intBox = Box(123)
    val strBox = Box("Hello")
    println(intBox.getValue())
    println(strBox.getValue())
}

medium

A. 123\nHello

B. Box@123\nBox@Hello

C. Error: Type mismatch

D. null\nnull

Solution

1. Step 1: Understand generic class usage

   The class Box holds a value of any type and returns it via getValue().

2. Step 2: Trace the main function

   Two instances are created: one with an integer 123 and one with a string "Hello". Calling getValue() returns these values.

3. Final Answer:

   123 Hello -> Option A

4. Quick Check:

   Generic class returns stored value [OK]

Hint: Generic class returns stored value as is [OK]

Common Mistakes:

• Expecting object reference output instead of value
• Confusing type inference causing errors
• Assuming null is returned

4. Identify the error in the following Kotlin generic class declaration:

class Container<T> {
    var item: T
    constructor(item: T) {
        this.item = item
    }
}

medium

A. No error, code is correct

B. Constructor syntax is incorrect

C. Generic type T is not declared properly

D. Property 'item' must be initialized or be abstract

Solution

1. Step 1: Check property initialization

   The property item is declared but not initialized and not marked as abstract or lateinit.

2. Step 2: Understand Kotlin property rules

   In Kotlin, non-null properties must be initialized or declared abstract/lateinit. Here, item is neither initialized nor marked, causing a compile error.

3. Final Answer:

   Property 'item' must be initialized or be abstract -> Option D

4. Quick Check:

   Uninitialized property causes error [OK]

Hint: Initialize properties or mark lateinit/abstract [OK]

Common Mistakes:

• Forgetting to initialize properties
• Misunderstanding constructor syntax
• Thinking generic declaration is wrong

5. You want to create a generic class PairBox that holds two values of possibly different types. Which is the correct declaration for this class in Kotlin?

hard

A. class PairBox(val first: T, val second: U)

B. class PairBox<T>(val first: T, val second: T)

C. class PairBox { val first: T; val second: T }

D. class PairBox(val first: Any, val second: Any)

Solution

1. Step 1: Understand requirement for two different types

   The class should accept two generic types, so it needs two type parameters, e.g., T and U.

2. Step 2: Check each option

   class PairBox(val first: T, val second: U) correctly declares two generic types and constructor parameters. class PairBox<T>(val first: T, val second: T) uses one type for both values, not allowing different types. class PairBox { val first: T; val second: T } has wrong property types (second is T, should be U). class PairBox(val first: Any, val second: Any) uses Any which is not generic.

3. Final Answer:

   class PairBox<T, U>(val first: T, val second: U) -> Option A

4. Quick Check:

   Two generics for two types [OK]

Hint: Use two type parameters for different types [OK]

Common Mistakes:

• Using one generic type for both values
• Confusing property types in class body
• Using Any instead of generics