Generic class declaration in Kotlin - Mini Project: Build & Apply

Generic class declaration

📖 Scenario: Imagine you want to create a box that can hold any type of item, like a box for toys, books, or fruits. Instead of making a new box for each type, you can make one generic box that works for all.

🎯 Goal: You will create a generic class called Box that can hold one item of any type. Then, you will create a box for an Int and a box for a String, and finally print the contents.

📋 What You'll Learn

Create a generic class called Box with one type parameter T

Add a property called item of type T to the class

Create a variable intBox of type Box<Int> holding the number 123

Create a variable stringBox of type Box<String> holding the text "Hello"

Print the contents of intBox and stringBox

💡 Why This Matters

🌍 Real World

Generic classes let you write flexible code that works with many data types without repeating yourself. For example, collections like lists and maps use generics.

💼 Career

Understanding generics is important for Kotlin developers to write reusable and type-safe code, which is a common requirement in professional software development.

1

Create the generic class

Create a generic class called Box with one type parameter T. Inside the class, add a property called item of type T. Use a primary constructor to set item.

Kotlin

# Your code here

Hint

Use class Box<T>(val item: T) to declare the generic class.

2

Create an integer box

Create a variable called intBox of type Box<Int> and set it to hold the number 123.

Kotlin

class Box(val item: T)
# Your code here

Hint

Write val intBox: Box<Int> = Box(123) to create the integer box.

3

Create a string box

Create a variable called stringBox of type Box<String> and set it to hold the text "Hello".

Kotlin

class Box(val item: T)

val intBox: Box = Box(123)
# Your code here

Hint

Write val stringBox: Box<String> = Box("Hello") to create the string box.

4

Print the box contents

Print the contents of intBox and stringBox using println. Print intBox.item first, then stringBox.item.

Kotlin

class Box(val item: T)

val intBox: Box = Box(123)
val stringBox: Box = Box("Hello")
# Your code here

Hint

Use println(intBox.item) and println(stringBox.item) to show the contents.

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