Generic class declaration in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a generic class in Kotlin?

A generic class in Kotlin is a class that can work with any data type. It uses a placeholder type parameter, allowing the class to be flexible and reusable with different types.

beginner

How do you declare a generic class in Kotlin?

You declare a generic class by adding a type parameter inside angle brackets after the class name. For example: <br><code>class Box<T>(val value: T)</code> declares a generic class named Box with a type parameter T.

beginner

What does the type parameter <code>T</code> represent in <code>class Box<T></code>?

The type parameter <code>T</code> is a placeholder for any type that will be specified when creating an instance of the class. It allows the class to hold or work with values of that type.

beginner

Can you create an instance of a generic class with a specific type? Give an example.

Yes. For example, val intBox = Box<Int>(123) creates an instance of Box that holds an Int value 123. The type Int replaces the generic type parameter T.

beginner

Why use generic classes instead of regular classes?

Generic classes let you write code once and use it with many types. This avoids repeating similar classes for each type and helps keep code clean and flexible.

How do you declare a generic class named Container with a type parameter T in Kotlin?

A class Container<T>

B class Container(T)

C class Container<T>()

D class Container[]

The correct syntax for declaring a generic class uses angle brackets with the type parameter: class Container

What does the type parameter in a generic class represent?

A A fixed type like Int or String

B A variable name

C A function inside the class

D A placeholder for any type specified when creating an instance

The type parameter is a placeholder that gets replaced by a real type when you create an instance of the generic class.

Which of these is a valid way to create an instance of a generic class Box with type String?

A val box = Box<String>("hello")

B val box = Box(hello)

C val box = Box<String>

D val box = Box<String>(123)

You must specify the type and provide a value of that type. Box("hello") is correct.

Why are generic classes useful?

A They replace functions

B They make code slower

C They allow code reuse with different types

D They only work with Int types

Generic classes let you write flexible code that works with many types, avoiding repetition.

What symbol is used to declare a type parameter in a Kotlin generic class?

A [ ]

B < >

C ( )

D { }

Angle brackets < > are used to declare type parameters in Kotlin generic classes.

Explain how to declare a generic class in Kotlin and why it is useful.

Think about how you can write one class to work with many types.

Describe how you create an instance of a generic class with a specific type and give an example.

Remember to specify the type inside angle brackets when creating the object.

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