"Mastering Kotlin Generics: Practical Examples & Tutorials"

Mastering Kotlin Generics: A Hands-On Example

Kotlin generics are a powerful tool that enables type safety and reusability in your code. They allow you to write flexible, type-checked code that works with various types. Let's dive into an example that demonstrates the essence of Kotlin generics.

Understanding the Problem: A Non-Generic Approach

Before we explore the generic solution, let's consider a non-generic approach to better understand the problem. Suppose we have a simple function that swaps the elements of two variables. Without generics, we might have separate functions for different types:

```kotlin fun swapInts(a: Int, b: Int) { val temp = a a = b b = temp } fun swapDoubles(a: Double, b: Double) { val temp = a a = b b = temp } ```

Introducing Generics: A More Flexible Solution

Now, let's refactor this code using Kotlin generics. Generics allow us to create a single, type-safe function that works with any type:

```kotlin fun swap(a: T, b: T) { val temp = a a = b b = temp } ```

Using the Generic Function

With our generic `swap` function, we can now swap elements of any type. Here's how you can use it:

```kotlin fun main() { var a = 5 var b = 10 swap(a, b) println("Swapped ints: $a, $b") // Output: Swapped ints: 10, 5 var c = 5.5 var d = 10.0 swap(c, d) println("Swapped doubles: $c, $d") // Output: Swapped doubles: 10.0, 5.5 } ```

Generic Constraints: Restricting the Acceptable Types

While generics provide flexibility, sometimes you might want to restrict the acceptable types. Kotlin allows you to add constraints to your generic types using the `where` keyword. For instance, let's create a function that only accepts types that implement the `Comparable` interface:

```kotlin fun > max(a: T, b: T): T { return if (a > b) a else b } ```

Generic Interfaces and Classes

Generics aren't limited to functions; you can also create generic interfaces and classes. Here's an example of a generic interface and a class that implements it:

```kotlin interface Box { fun put(item: T) fun get(): T } class IntBox : Box { private var value: Int = 0 override fun put(item: Int) { value = item } override fun get(): Int { return value } } ```

Conclusion

Kotlin generics are a powerful tool that enables you to write flexible, type-safe code. By understanding and utilizing generics, you can create more reusable and maintainable code. In this article, we've explored an example that demonstrates the essence of Kotlin generics and their various use cases.