62. Generics in Kotlin: Basic usage and type parameters

March 23, 2025

🚀 Generics in Kotlin: Mastering Type Parameters and Generic Programming

Welcome, Kotlin developers! Today we'll dive deep into one of the most powerful features of Kotlin - Generics. Understanding generics is crucial for writing flexible, type-safe, and reusable code. We'll explore how generics help you create more abstract and efficient solutions across various programming scenarios.

📍 What Are Generics?

Generics allow you to write code that can work with different types while maintaining type safety. They provide a way to create classes, interfaces, and functions that can operate on objects of various types without sacrificing compile-time type checking.

🔑 Basic Generic Class Declaration

class GenericBox(val content: T) {
    fun getContent(): T = content
}

// Usage
val stringBox = GenericBox("Hello Kotlin")
val intBox = GenericBox(42)

🎯 Generic Functions

fun  printItem(item: T) {
    println("Item: $item")
}

// Multiple type parameters
fun  createMap(key: K, value: V): Map {
    return mapOf(key to value)
}

📌 Type Constraints

Kotlin allows you to restrict type parameters using type constraints:

// Restrict to Number subclasses
fun  sumOfList(list: List): Double {
    return list.sumByDouble { it.toDouble() }
}

// Multiple constraints
interface Drawable
interface Movable

fun  processItem(item: T) where T : Drawable, T : Movable {
    // Process drawable and movable item
}

🔬 Variance in Generics

Kotlin provides three variance modifiers: invariant, covariant, and contravariant.

// Covariant - read-only collections
class Producer(private val value: T) {
    fun get(): T = value
}

// Contravariant - consumer scenarios
class Consumer {
    fun consume(item: T) { /* process item */ }
}

💡 Practical Exercises

Create a generic swap function that exchanges elements in an array
Implement a generic repository class with CRUD operations
Design a type-safe cache with generics and constraints
Build a generic result wrapper with success and error states
Create a generic sorting method that works with Comparable types

Pro Tip: Always prefer immutable generic collections and use type constraints to create more robust code.

🏁 Conclusion

Generics in Kotlin provide powerful abstractions that enable writing more flexible and type-safe code. By understanding type parameters, constraints, and variance, you can create more generic and reusable components.

#Kotlin #Generics #TypeSafety #ProgrammingTips

📱 Stay Updated with Android Tips!

Join our Telegram channel for exclusive content, useful tips, and the latest Android updates!

👉 Join Our Telegram Channel

Get daily updates and be part of our growing Android community!

android4n00bs