Generics в Kotlin: зачем нужны и как использовать для начинающих

Введение в Generics в Kotlin

При разработке на Kotlin рано или поздно вы столкнетесь с ситуацией, когда один и тот же алгоритм или структура данных должны работать с разными типами объектов. Представьте, что вы пишете функцию для поиска максимального элемента в списке — она должна одинаково хорошо обрабатывать как список чисел, так и список строк. Без специальных инструментов вам пришлось бы писать отдельные реализации для каждого типа. Именно здесь на помощь приходят Generics (дженерики или обобщения).

Generics в Kotlin — это мощный механизм, позволяющий создавать классы, функции и интерфейсы, которые работают с различными типами данных, сохраняя при этом строгую типизацию на этапе компиляции. В этой статье мы разберем, зачем нужны Generics, и научимся их использовать на практических примерах.

Что такое Generics и зачем они нужны?

Представьте себе коробку, которая может хранить любой предмет: книгу, телефон или яблоко. В программировании такая "коробка" — это обобщенный класс или функция. Без Generics вам пришлось бы использовать тип Any (аналог Object в Java) и постоянно делать приведение типов, что чревато ошибками.

Проблема без Generics

fun <T> printList(list: List<T>) {
    for (item in list) {
        println(item)
    }
}

// Без Generics пришлось бы писать так:
fun printListAny(list: List<Any>) {
    for (item in list) {
        // Нужно проверять тип и приводить
        if (item is String) {
            println("Строка: $item")
        } else if (item is Int) {
            println("Число: $item")
        }
    }
}

Преимущества использования Generics

• Безопасность типов — компилятор проверяет корректность использования типов на этапе компиляции.
• Повторное использование кода — одна функция или класс работают с любыми типами.
• Отказ от явных приведений — код становится чище и менее подвержен ошибкам.
• Производительность — нет накладных расходов на проверку типов во время выполнения.

Основные конструкции Generics в Kotlin

1. Generic-функции

Generic-функция — это функция, которая принимает параметр типа. Объявляется она с помощью угловых скобок <T> перед именем функции.

fun <T> getFirstElement(list: List<T>): T? {
    return list.firstOrNull()
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val firstNumber = getFirstElement(numbers)
    println("Первое число: $firstNumber") // 1

    val words = listOf("Кот", "Собака", "Попугай")
    val firstWord = getFirstElement(words)
    println("Первое слово: $firstWord") // Кот
}

Обратите внимание: тип T автоматически выводится компилятором. Вы можете явно указать его, но это не обязательно:

val firstNumber = getFirstElement<Int>(numbers)

2. Generic-классы

Generic-класс — это класс, который может хранить и обрабатывать объекты любого типа. Отличный пример — стандартный класс Box.

class Box<T>(private val content: T) {
    fun getContent(): T {
        return content
    }

    fun isTypeOf(typeClass: Class<*>): Boolean {
        return typeClass.isInstance(content)
    }
}

fun main() {
    val stringBox = Box("Привет, мир!")
    println(stringBox.getContent()) // Привет, мир!

    val intBox = Box(42)
    println(intBox.getContent()) // 42

    // Проверка типа
    println(intBox.isTypeOf(Int::class.java)) // true
}

3. Generic-интерфейсы

Интерфейсы тоже могут быть обобщенными. Это особенно полезно при создании коллекций или контрактов для обработки данных.

interface Repository<T> {
    fun save(item: T)
    fun findById(id: Int): T?
    fun findAll(): List<T>
}

class UserRepository : Repository<User> {
    private val users = mutableListOf<User>()

    override fun save(user: User) {
        users.add(user)
    }

    override fun findById(id: Int): User? {
        return users.find { it.id == id }
    }

    override fun findAll(): List<User> {
        return users.toList()
    }
}

data class User(val id: Int, val name: String)

fun main() {
    val repo = UserRepository()
    repo.save(User(1, "Анна"))
    repo.save(User(2, "Борис"))
    println(repo.findById(1)) // User(id=1, name=Анна)
}

Ограничения (Bounded Type Parameters)

Иногда нужно ограничить типы, которые могут быть использованы с дженериком. Например, вы хотите, чтобы функция работала только с числами. Для этого используются верхние границы (upper bounds).

fun <T : Number> sumOfNumbers(list: List<T>): Double {
    return list.sumOf { it.toDouble() }
}

fun main() {
    val ints = listOf(1, 2, 3)
    println(sumOfNumbers(ints)) // 6.0

    val doubles = listOf(1.5, 2.5, 3.0)
    println(sumOfNumbers(doubles)) // 7.0

    // Ошибка компиляции: String не является подтипом Number
    // val strings = listOf("a", "b")
    // println(sumOfNumbers(strings))
}

Можно указать несколько ограничений с помощью ключевого слова where:

fun <T> printIfComparable(item: T) where T : Comparable<T>, T : CharSequence {
    println("Сравниваем: ${item.length}")
}

fun main() {
    printIfComparable("Kotlin") // Сравниваем: 6
    // printIfComparable(42) // Ошибка: Int не является CharSequence
}

Вариантность: ковариантность и контравариантность

В Kotlin есть важная концепция вариантности (variance), которая определяет, как обобщенные типы связаны друг с другом через наследование.

Ковариантность (out)

Помечая параметр типа как out, вы говорите, что класс может производить (возвращать) объекты этого типа, но не может их принимать. Это позволяет присваивать List<String> переменной типа List<