Kotlin Generic Classes 🎯

Welcome to our deep dive into Kotlin Generic Classes! This tutorial is designed for both beginners and intermediate learners who want to understand the power of generics in Kotlin programming. By the end of this lesson, you'll be able to write your own generic classes and understand their practical applications in real-world projects.

Why Generic Classes? 💡

Generic classes are a way to create reusable classes that work with different data types. They help you write more flexible and maintainable code, as you can define a class once and use it with various data types without having to create multiple versions of the same class.

Getting Started 📝

Before we dive into generic classes, let's make sure you're familiar with the basics of Kotlin classes and data types. If you're new to Kotlin, we recommend checking out our Kotlin Basics tutorial first.

Defining a Generic Class ✅

In Kotlin, we define a generic class using the <T> syntax, where T is a placeholder for any data type. Here's an example of a simple generic class:

kotlin

class Box<T>(val item: T) {
    fun getItem(): T {
        return item
    }
}

In this example, T can be any data type, like Int, String, or even another class.

Using a Generic Class 💡

To use our Box generic class, we simply need to specify the data type we want to use when creating an instance of the class:

kotlin

val boxOfInt = Box<Int>(42)
val boxOfString = Box<String>("Hello, World!")

In this example, we have created two instances of the Box class: one that holds an Int and another that holds a String.

Generic Functions and Methods 💡

Besides classes, we can also create generic functions and methods in Kotlin. Here's an example:

kotlin

fun <T> printData(data: T) {
    println(data)
}

val intData = 42
val stringData = "Example data"

printData(intData)
printData(stringData)

In this example, we've created a printData function that takes a generic data type as a parameter. We can call this function with different data types without any issues.

Type Parameters and Constraints 📝

In the examples above, we've used a single type parameter T. However, you can also use multiple type parameters and apply constraints to them. Here's an example:

kotlin

class Pair<K, V> (val first: K, val second: V)

val pairOfIntAndString = Pair(42, "Example")

In this example, we've defined a Pair class that takes two type parameters: K and V. This allows us to create pairs where the first element could be an Int, String, or any other type, and the second element could be a different type altogether.

Quiz 📝

By understanding and using generic classes, you'll be able to write more robust and reusable code in your Kotlin projects. Happy coding! 🚀