Generic Classes

class Box<T>(val item: T)

fun main() {
    val intBox = Box(42)
    val stringBox = Box("Kotlin")
    println("${intBox.item}, ${stringBox.item}")
}

class Pair2<A, B>(val first: A, val second: B)

fun main() {
    val pair = Pair2("age", 30)
    println("${pair.first} = ${pair.second}")
}

class Container<T> {
    private val items = mutableListOf<T>()
    fun add(item: T) = items.add(item)
    fun all(): List<T> = items
}

fun main() {
    val container = Container<String>()
    container.add("Kotlin")
    container.add("Generics")
    println(container.all())
}

class KeyValue<K, V>(val key: K, val value: V) {
    fun describe() = "$key -> $value"
}

fun main() {
    val entry = KeyValue("name", "Kotlin")
    println(entry.describe())
}

1. Writing a separate class for every type it needs to hold (e.g. IntBox, StringBox) instead of one generic Box<T>.
2. Forgetting to specify the type argument when it cannot be inferred, such as creating an empty generic collection with no elements to infer from.
3. Confusing the type parameter name (like T) with an actual type; T is just a placeholder name, conventionally a single capital letter.

• A generic class declares one or more type parameters in angle brackets after its name, such as class Box<T>(val item: T).
• The type parameter T acts as a placeholder that gets replaced with a concrete type when the class is used.
• Type arguments are often inferred automatically from constructor arguments, but can be specified explicitly when needed.
• Generic classes avoid duplicating the same logic for every different type it might need to hold.