Что такое delegated properties в Kotlin? Приведите примеры использования by lazy и by observable.

Delegated Properties (Делегированные свойства) в Kotlin

Делегированные свойства — это механизм в Kotlin, позволяющий делегировать (передавать) ответственность за реализацию getter и setter свойства внешнему объекту — делегату. Это один из наиболее ярких примеров использования паттерна делегирования в языке, который позволяет:

• Избавиться от повторяющегося boilerplate-кода (например, проверок или ленивых вычислений).
• Внедрять сложную логику работы с свойствами через стандартизированные интерфейсы.
• Создавать собственные делегаты для специфических задач.

Основная идея: вместо того чтобы писать свои собственные get/set методы для каждого свойства, мы можем использовать готовые реализации, предоставленные Kotlin или созданные самостоятельно. Для этого используется ключевое слово by.

Как это работает?

Любой делегат должен реализовывать один из двух интерфейсов:

• ReadOnlyProperty<R, T> — для свойств только для чтения (val). Требует реализации метода getValue(thisRef: R, property: KProperty<*>): T.
• ReadWriteProperty<R, T> — для изменяемых свойств (var). Требует реализации методов getValue и setValue(thisRef: R, property: KProperty<*>, value: T).

thisRef — ссылка на объект-владельца свойства, property — метаинформация о самом свойстве (например, его имя).

Примеры использования встроенных делегатов

1. by lazy — ленивая инициализация

lazy — один из самых популярных делегатов. Он используется для ленивой (отложенной) инициализации val свойств. Значение вычисляется только при первом обращении к свойству и затем хранится для повторных использований. Это полезно для:

• Ресурсоёмких вычислений.
• Свойств, которые могут не потребоваться в течение жизни объекта.
• Оптимизации производительности.

lazy принимает лямбду для вычисления значения и может использовать один из трех режимов синхронизации:

• LazyThreadSafetyMode.SYNCHRONIZED (default) — безопасный для многопоточности.
• LazyThreadSafetyMode.PUBLICATION — допускает несколько вычислений, но возвращает первое завершенное.
• LazyThreadSafetyMode.NONE — без синхронизации, только для однопоточных контекстов.

class HeavyResourceLoader {
    // Ресурс загружается только при первом обращении к resource
    val resource: String by lazy {
        println("Выполняется тяжелая загрузка ресурса...")
        // Например, чтение из файла или сетевой запрос
        "Данные загруженного ресурса"
    }
    
    val quickResource: Int by lazy(LazyThreadSafetyMode.NONE) {
        // Быстрое вычисление без необходимости синхронизации
        42
    }
}

fun main() {
    val loader = HeavyResourceLoader()
    println(loader.resource) // Выводит: "Выполняется тяжелая загрузка ресурса..." затем "Данные загруженного ресурса"
    println(loader.resource) // Выводит только: "Данные загруженного ресурса" (повторное вычисление не происходит)
}

2. by Delegates.observable — наблюдаемые свойства

Observable делегат используется для var свойств и позволяет отслеживать изменения их значения. При каждом изменении свойства вызывается callback-лямбда, которая получает старое значение, новое значение и метаинформацию о свойстве. Это удобно для:

• Валидации данных.
• Логирования изменений.
• Синхронизации с другими частями системы (например, UI).
• Реализации некоторых аспектов реактивного программирования.

import kotlin.properties.Delegates

class User {
    var name: String by Delegates.observable("<unnamed>") { prop, old, new ->
        println("Свойство ${prop.name} изменено: '$old' -> '$new'")
        // Можно добавить валидацию
        if (new.trim().isEmpty()) {
            println("Имя не может быть пустым!")
        }
    }
    
    var age: Int by Delegates.observable(0) { _, old, new ->
        if (new < 0) {
            println("Возраст не может быть отрицательным! Используется старое значение: $old")
            // Однако, значение уже изменено — делегат не предотвращает изменение.
            // Для предотвращения нужен vetoable (см. ниже).
        }
    }
}

fun main() {
    val user = User()
    user.name = "Алексей" // Выводит: Свойство name изменено: '<unnamed>' -> 'Алексей'
    user.name = ""        // Выводит: Свойство name изменено: 'Алексей' -> '' и 'Имя не может быть пустым!'
    user.age = 25        // Выводит ничего (нет callback для положительного значения)
    user.age = -5        // Выводит: Возраст не может быть отрицательным! Используется старое значение: 25
}

Связь с vetoable

Kotlin также предоставляет делегат Delegates.vetoable, который похож на observable, но позволяет "отвергнуть" (veto) изменение, если условие в лямбде не выполняется. Лямбда возвращает Boolean: true — изменение принимается, false — отвергается, сохраняется старое значение.

var positiveAge: Int by Delegates.vetoable(0) { _, old, new ->
    new >= 0 // Изменение принимается только если новое значение >= 0
}

Заключение

Делегированные свойства — мощный инструмент Kotlin, который способствует декомпозиции логики и повышает читаемость кода. Они позволяют инкапсулировать поведение, связанное с доступом к свойствам, в отдельные объекты-делегаты.

Кроме lazy и observable, стандартная библиотека предоставляет делегаты:

• Delegates.notNull() — для свойств, которые не могут быть null, но инициализируются позже (аналог lateinit для типов, не поддерживаемых lateinit).
• Delegates.map() — для хранения свойств в Map.

Также разработчики могут создавать собственные делегаты для таких задач, как инъекция зависимостей, сохранение в SharedPreferences (Android), или реактивные биндинги. Это делает delegated properties фундаментальным концептом для создания чистого, модульного и эффективного кода на Kotlin.