🎯 Kotlin

OOP: Kapselung und Polymorphie in Kotlin: Eine ausführliche Anleitung

Lektion 18 / 35 • Vollständige Lektüre-Theorie

Что это такое и зачем? (аналогия из реальной жизни)

Представь, что ты собираешь сложный конструктор LEGO Technic — например, гоночный автомобиль. У тебя есть сотни деталей: шестерёнки, оси, колёса, двигатель. Если бы все детали лежали в одной куче, собрать машину было бы невозможно. Но производитель LEGO поступил умно: он упаковал каждую сложную деталь в отдельный блок. Внутри блока спрятаны шестерёнки и пружины, а снаружи — только простые крепления, чтобы соединять с другими блоками. Это и есть инкапсуляция — сокрытие сложности внутри объекта.

Теперь представь, что ты можешь управлять разными машинами: гоночной, грузовиком и трактором. У всех есть педаль газа. Но нажимаешь ты на неё одинаково, а машины реагируют по-разному: гоночная разгоняется за 3 секунды, грузовик — медленно, а трактор начинает пахать поле. Ты используешь одну и ту же команду «нажать газ», а поведение разное. Это полиморфизм — способность разных объектов по-разному реагировать на одинаковые команды.

💡 Запомни главное: Инкапсуляция — это про «что внутри — никого не касается». Полиморфизм — про «делай одно и то же, получай разный результат».

В программировании эти принципы помогают нам писать код, который легко читать, изменять и расширять. Если ты создаёшь игру, где есть разные персонажи (маги, воины, лучники), то с помощью полиморфизма ты сможешь дать всем команду «атаковать», и каждый сделает это по-своему. А инкапсуляция спрячет сложные расчёты здоровья, маны и урона внутри каждого персонажа.

Теория: как это работает изнутри

Инкапсуляция — защита данных

В объектно-ориентированном программировании (ООП) инкапсуляция объединяет данные (свойства) и методы (функции) внутри класса. Представь класс как чертёж, а объект — как реальную деталь, созданную по этому чертежу.

У каждого объекта есть публичный интерфейс — то, что видно снаружи (методы, к которым можно обратиться), и приватная реализация — то, что скрыто внутри (внутренние данные и вспомогательные методы).

В Kotlin для управления доступом используются модификаторы видимости:

Модификатор	Видимость	Пример из жизни
`private`	Только внутри класса	Личный дневник
`protected`	Внутри класса и в наследниках	Семейный альбом
`internal`	Внутри одного модуля	Документы отдела
`public`	Везде (по умолчанию)	Витрина магазина

Полиморфизм — единый интерфейс

Полиморфизм бывает двух видов: статический (перегрузка методов) и динамический (переопределение методов).

Статический полиморфизм — это когда у тебя есть несколько методов с одинаковым именем, но разными параметрами. Компилятор сам решает, какой метод вызвать, глядя на аргументы. Например, метод print может принимать и строку, и число, и список.

Динамический полиморфизм — это когда ты объявляешь метод в базовом классе, а в классах-наследниках даёшь ему новую реализацию. В Kotlin для этого нужно пометить метод в базовом классе словом open, а в наследнике — override.

⚠️ Важно: В Kotlin все методы по умолчанию final (нельзя переопределить). Если хочешь разрешить переопределение — явно пиши open.

Синтаксис в Kotlin: все формы и варианты

Инкапсуляция: геттеры и сеттеры

В Kotlin нет традиционных геттеров и сеттеров как в Java. Вместо этого используются свойства с автоматическими аксессорами:

class User {
    // Свойство с публичным геттером и приватным сеттером
    var age: Int = 0
        private set  // изменить возраст можно только внутри класса
    
    // Свойство только для чтения
    val name: String = "Аноним"
    
    // Кастомный геттер
    val isAdult: Boolean
        get() = age >= 18  // вычисляется каждый раз при обращении
}

Полиморфизм: наследование и интерфейсы

В Kotlin есть два способа реализовать полиморфизм:

1. Наследование классов:

open class Animal {  // open — разрешаем наследование
    open fun makeSound() {  // open — разрешаем переопределение
        println("Животное издаёт звук")
    }
}

class Dog : Animal() {
    override fun makeSound() {  // override — переопределяем
        println("Гав-гав!")
    }
}

2. Интерфейсы:

interface Flyable {
    fun fly()  // абстрактный метод — без реализации
}

class Bird : Flyable {
    override fun fly() {
        println("Птица летит, махая крыльями")
    }
}

class Plane : Flyable {
    override fun fly() {
        println("Самолёт летит на реактивной тяге")
    }
}

Sealed классы — особый случай полиморфизма

Sealed классы (запечатанные) позволяют ограничить иерархию: все наследники должны быть объявлены в том же файле. Это удобно для обработки состояний:

sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
    object Loading : Result()
}

fun handleResult(result: Result) {
    when (result) {
        is Result.Success -> println("Данные: ${result.data}")
        is Result.Error -> println("Ошибка: ${result.message}")
        Result.Loading -> println("Загрузка...")
        // when должен быть исчерпывающим — компилятор проверит
    }
}

Примеры кода — от простого к сложному

Пример 1: Простейшая инкапсуляция — банковский счёт

class BankAccount {
    // Приватное поле — никто снаружи не имеет к нему прямого доступа
    private var balance: Double = 0.0
    
    // Публичный метод для пополнения счёта
    fun deposit(amount: Double) {
        if (amount > 0) {
            balance += amount
            println("Пополнено на $amount. Баланс: $balance")
        } else {
            println("Сумма пополнения должна быть положительной")
        }
    }
    
    // Публичный метод для снятия денег
    fun withdraw(amount: Double) {
        if (amount > 0 && amount <= balance) {
            balance -= amount
            println("Снято $amount. Баланс: $balance")
        } else {
            println("Недостаточно средств или неверная сумма")
        }
    }
    
    // Публичный метод для проверки баланса (только чтение)
    fun getBalance(): Double {
        return balance
    }
}

fun main() {
    val account = BankAccount()
    account.deposit(1000.0)  // Пополнено на 1000.0. Баланс: 1000.0
    account.withdraw(500.0)  // Снято 500.0. Баланс: 500.0
    // account.balance = 999999.0  // Ошибка! balance — private
    println("Текущий баланс: ${account.getBalance()}")  // 500.0
}

Объяснение: Мы спрятали переменную balance от внешнего мира. Теперь никто не может просто взять и изменить баланс — только через наши методы с проверками. Это защищает данные от некорректных изменений.

Пример 2: Геттеры и сеттеры в стиле Kotlin

class Temperature {
    // Храним температуру в Цельсиях
    private var celsius: Double = 0.0
    
    // Свойство для работы с Фаренгейтами
    var fahrenheit: Double
        get() = celsius * 9/5 + 32  // геттер — конвертирует в Фаренгейты
        set(value) {
            celsius = (value - 32) * 5/9  // сеттер — конвертирует обратно
        }
    
    // Свойство только для чтения
    val inCelsius: Double
        get() = celsius
    
    // Свойство с проверкой в сеттере
    var city: String = "Москва"
        set(value) {
            if (value.isNotBlank()) {
                field = value  // field — это backing field (резервное поле)
            } else {
                println("Название города не может быть пустым")
            }
        }
}

fun main() {
    val temp = Temperature()
    temp.fahrenheit = 98.6  // Устанавливаем через сеттер
    println("В Цельсиях: ${temp.inCelsius}")  // 37.0
    println("В Фаренгейтах: ${temp.fahrenheit}")  // 98.6
}

Объяснение: Мы используем кастомные геттеры и сеттеры. Когда пользователь устанавливает температуру в Фаренгейтах, она автоматически конвертируется в Цельсии для хранения. Обрати внимание на ключевое слово field — это ссылка на резервное поле, которое Kotlin создаёт автоматически.

Пример 3: Базовый полиморфизм — геометрические фигуры

// Базовый класс с открытым методом
open class Shape {
    open fun area(): Double {
        return 0.0  // Базовая реализация, если фигура не определена
    }
    
    open fun draw() {
        println("Рисуем фигуру")
    }
}

// Класс-наследник: круг
class Circle(private val radius: Double) : Shape() {
    override fun area(): Double {
        return Math.PI * radius * radius  // πr²
    }
    
    override fun draw() {
        println("Рисуем круг радиусом $radius")
    }
}

// Класс-наследник: прямоугольник
class Rectangle(private val width: Double, private val height: Double) : Shape() {
    override fun area(): Double {
        return width * height
    }
    
    override fun draw() {
        println("Рисуем прямоугольник $width × $height")
    }
}

fun main() {
    val shapes: List = listOf(Circle(5.0), Rectangle(4.0, 6.0))
    
    for (shape in shapes) {
        shape.draw()  // Полиморфизм: вызывается правильный метод
        println("Площадь: ${shape.area()}")
        println("---")
    }
}

Объяснение: У нас есть список фигур, но мы не знаем, какая именно фигура внутри. Благодаря полиморфизму, при вызове draw() и area() выполняются правильные версии методов для каждой фигуры. Это и есть «один интерфейс — много реализаций».

Пример 4: Полиморфизм через интерфейсы — платёжная система

// Интерфейс — контракт, который должны выполнять все платёжные системы
interface PaymentSystem {
    fun pay(amount: Double): Boolean
    fun refund(transactionId: String): Boolean
    fun getBalance(): Double
}

// Реализация для кредитной карты
class CreditCard(private val cardNumber: String) : PaymentSystem {
    private var balance: Double = 10000.0  // Кредитный лимит
    
    override fun pay(amount: Double): Boolean {
        if (amount <= balance) {
            balance -= amount
            println("Оплата картой $cardNumber: $amount")
            return true
        }
        println("Недостаточно средств на карте")
        return false
    }
    
    override fun refund(transactionId: String): Boolean {
        println("Возврат по транзакции $transactionId на карту $cardNumber")
        balance += 500.0  // Условно возвращаем 500
        return true
    }
    
    override fun getBalance(): Double = balance
}

// Реализация для электронного кошелька
class EWallet(private val walletId: String) : PaymentSystem {
    private var balance: Double = 5000.0
    
    override fun pay(amount: Double): Boolean {
        if (amount <= balance) {
            balance -= amount
            println("Оплата из кошелька $walletId: $amount")
            return true
        }
        println("Недостаточно средств в кошельке")
        return false
    }
    
    override fun refund(transactionId: String): Boolean {
        println("Возврат $transactionId в кошелёк $walletId")
        balance += 300.0
        return true
    }
    
    override fun getBalance(): Double = balance
}

fun processPayment(paymentSystem: PaymentSystem, amount: Double) {
    println("Обработка платежа...")
    if (paymentSystem.pay(amount)) {
        println("Платёж успешен")
    } else {
        println("Платёж отклонён")
    }
}

fun main() {
    val card = CreditCard("1234-5678-9012-3456")
    val wallet = EWallet("EW-2024-001")
    
    processPayment(card, 1500.0)   // Оплата картой
    processPayment(wallet, 2000.0) // Оплата кошельком
}

Объяснение: Функция processPayment принимает любой объект, реализующий интерфейс PaymentSystem. Ей всё равно, карта это или кошелёк — она просто вызывает pay(). Это позволяет легко добавлять новые способы оплаты (например, криптовалюту) без изменения существующего кода.

Пример 5: Композиция вместо наследования — гибкая инкапсуляция

// Композиция: объект содержит другие объекты, а не наследует их
class Engine(private val horsePower: Int) {
    fun start() {
        println("Двигатель мощностью $horsePower л.с. запущен")
    }
    
    fun stop() {
        println("Двигатель остановлен")
    }
}

class Wheels(private val count: Int) {
    fun rotate() {
        println("$count колёс вращаются")
    }
}

class Car(private val model: String) {
    // Композиция: машина состоит из двигателя и колёс
    private val engine = Engine(150)
    private val wheels = Wheels(4)
    
    fun drive() {
        println("Автомобиль $model начинает движение")
        engine.start()
        wheels.rotate()
        println("Машина едет!")
    }
    
    fun stop() {
        engine.stop()
        println("Машина остановлена")
    }
}

fun main() {
    val myCar = Car("Tesla Model 3")
    myCar.drive()
    myCar.stop()
}

Объяснение: Вместо того чтобы наследовать свойства от класса «Транспортное средство», мы собираем машину из отдельных компонентов (двигатель, колёса). Каждый компонент инкапсулирует свою сложность. Если мы захотим сделать электромобиль, мы просто заменим двигатель — не трогая колёса и кузов.

Пример 6: Sealed классы для обработки состояний

// Моделируем состояния загрузки данных с сервера
sealed class NetworkState {
    object Idle : NetworkState()  // Ничего не делаем
    object Loading : NetworkState()  // Загружаем
    data class Success(val data: String) : NetworkState()  // Успех
    data class Error(val code: Int, val message: String) : NetworkState()  // Ошибка
}

class DataLoader {
    private var state: NetworkState = NetworkState.Idle
    
    fun loadData() {
        state = NetworkState.Loading
        println("Загрузка данных...")
        
        // Имитация загрузки
        Thread.sleep(1000)
        
        // Случайный успех или ошибка
        if (Math.random() > 0.3) {
            state = NetworkState.Success("Важные данные: {name: 'Kotlin', version: 2.0}")
        } else {
            state = NetworkState.Error(404, "Данные не найдены")
        }
    }
    
    fun getState(): NetworkState = state
}

fun main() {
    val loader = DataLoader()
    loader.loadData()
    
    when (val currentState = loader.getState()) {
        is NetworkState.Idle -> println("Ожидание команд")
        is NetworkState.Loading -> println("Идёт загрузка...")
        is NetworkState.Success -> println("✅ Успех: ${currentState.data}")
        is NetworkState.Error -> println("❌ Ошибка ${currentState.code}: ${currentState.message}")
    }
}

Объяснение: Sealed классы гарантируют, что мы обработали все возможные состояния. Компилятор проверит, что в when перечислены все варианты. Это мощный инструмент для моделирования конечных автоматов.

Пример 7: Data классы и деструктуризация — удобная инкапсуляция

// Data класс автоматически генерирует equals, hashCode, toString, copy
data class Student(
    val id: Int,
    val name: String,
    val grade: Double
) {
    // Кастомное свойство с геттером
    val isPassing: Boolean
        get() = grade >= 3.0
    
    // Приватный метод для внутреннего использования
    private fun calculateScholarship(): Double {
        return if (grade >= 4.5) 5000.0 else if (grade >= 3.5) 3000.0 else 0.0
    }
    
    // Публичный метод, использующий приватный
    fun getScholarshipInfo(): String {
        val amount = calculateScholarship()
        return if (amount > 0) "Стипендия: $amount руб." else "Стипендии нет"
    }
}

fun main() {
    val student = Student(1, "Анна", 4.8)
    
    // Деструктуризация — разбиваем объект на части
    val (id, name, grade) = student
    println("Студент: $name (ID: $id), средний балл: $grade")
    
    // Используем кастомное свойство
    println("Сдал экзамены: ${if (student.isPassing) "да" else "нет"}")
    
    // Используем метод
    println(student.getScholarshipInfo())
    
    // Копирование с изменением (благодаря data class)
    val updatedStudent = student.copy(grade = 3.2)
    println("Обновлённый студент: ${updatedStudent.name}, балл: ${updatedStudent.grade}")
    println("Стипендия: ${updatedStudent.getScholarshipInfo()}")
}

Объяснение: Data классы — это «ленивая» инкапсуляция. Kotlin сам генерирует все стандартные методы. Мы добавляем только свою логику. Деструктуризация позволяет удобно «разобрать» объект на переменные.

Сравнение с Python: чем похоже и чем отличается

Характеристика	Kotlin	Python
Инкапсуляция	Строгая: `private`, `protected`, `internal`	Соглашение: `_private` (подчёркивание), `__name_mangling`
Геттеры/сеттеры	Встроенные свойства с `get()` и `set()`	Декораторы `@property`, `@setter`
Полиморфизм	Явный: `open` и `override`	Неявный: «утиная типизация» — если объект имеет метод, он подходит
Наследование	Одиночное, классы по умолчанию `final`	Множественное, все классы можно наследовать
Интерфейсы	Есть, могут иметь реализацию по умолчанию	Через абстрактные классы (ABC) или протоколы
Data классы	Встроенные `data class`	Через `dataclasses.dataclass` или `NamedTuple`
Sealed классы	Есть, мощный инструмент	Нет прямого аналога (используют Enum или Union)
Статический полиморфизм	Перегрузка методов (разные параметры)	Нет перегрузки — используется `args` и `*kwargs`

🔑 Ключевое отличие: Kotlin — статически типизированный язык. Компилятор проверяет типы на этапе компиляции. Python — динамически типизированный. В Python ты можешь передать любой объект в любую функцию, и ошибка вылезет только во время выполнения. Kotlin требует явно указывать, какие методы можно переопределять (open), а Python позволяет переопределить любой метод.

Типичные ошибки и подводные камни

Ошибка 1: Забыл про `open`

class Parent {
    fun sayHello() { println("Привет") }  // По умолчанию final!
}

class Child : Parent() {
    // override fun sayHello() { println("Привет от ребёнка") }  // Ошибка!
    // 'sayHello' is final and cannot be overridden
}

Решение: Добавь open перед методом в родительском классе.

Ошибка 2: Путаница между `val` и `var`

class Person(val name: String) {  // val — только для чтения
    fun changeName(newName: String) {
        // name = newName  // Ошибка! Val cannot be reassigned
    }
}

Решение: Используй var, если свойство должно изменяться.

Ошибка 3: Нарушение инкапсуляции через компаньон-объекты

class Database {
    private var connection: String = "closed"
    
    companion object {
        fun forceOpen(db: Database) {
            db.connection = "open"  // Доступ к private полю! Плохая практика
        }
    }
}

Решение: Компаньон-объект имеет доступ к приватным членам класса. Используй это только для фабричных методов, не для обхода инкапсуляции.

Ошибка 4: Неправильное использование `internal`

// Модуль A
internal class SecretHelper {
    fun doSecret() { println("Секрет") }
}

// Модуль B (другой Gradle-модуль)
// val helper = SecretHelper()  // Ошибка! Не видно из другого модуля

Решение: Помни, что internal — это видимость в пределах одного модуля (Gradle-проекта). Для библиотек используй public или private.

Ошибка 5: Забыл про `sealed` в `when`

sealed class Color {
    object Red : Color()
    object Green : Color()
    object Blue : Color()
}

fun describeColor(color: Color) {
    when (color) {
        is Color.Red -> println("Красный")
        is Color.Green -> println("Зелёный")
        // Забыли Blue! Компилятор выдаст предупреждение
    }
}

Решение: Добавь else -> или обработай все варианты. Для sealed классов лучше обрабатывать все явно.

Лучшие практики и советы профессионалов

Принцип наименьших привилегий. Начинай с private. Открывай доступ только когда это действительно нужно. Лучше иметь слишком много private, чем слишком мало.
Используй data классы для моделей данных. Они автоматически дают тебе equals, hashCode, toString и copy. Это экономит часы написания шаблонного кода.
Предпочитай композицию наследованию. Вместо «Машина является Транспортным средством» думай «Машина содержит Двигатель и Колёса». Это делает код гибче.
Используй sealed классы для ограниченных иерархий. Если ты знаешь все возможные варианты (состояния загрузки, типы ошибок, результаты операций) — sealed классы дадут тебе безопасность на этапе компиляции.
Не бойся создавать маленькие классы. Один класс — одна ответственность. Если класс делает больше одной вещи — разбей его.
Используй интерфейсы для определения контрактов. Это позволяет легко заменять реализации (например, переключиться с локальной базы данных на облачную).
Пиши тесты для публичных методов. Инкапсуляция позволяет тебе менять внутреннюю реализацию, не ломая тесты — если публичный интерфейс остаётся тем же.
Избегай «божественных объектов». Объект, который знает всё и делает всё — это антипаттерн. Разделяй ответственность.

Вопросы для самопроверки

Что такое инкапсуляция и зачем она нужна?
Ответ: Инкапсуляция — это сокрытие внутренних данных и реализации объекта. Она нужна для защиты данных от некорректного использования и для упрощения работы с объектом (пользователь видит только нужные методы).
Какие модификаторы видимости есть в Kotlin и что они означают?
Ответ: private (только внутри класса), protected (класс и наследники), internal (внутри модуля), public (везде, по умолчанию).
В чём разница между статическим и динамическим полиморфизмом?
Ответ: Статический (перегрузка) — методы с одинаковым именем, но разными параметрами, выбор метода на этапе компиляции. Динамический (переопределение) — метод базового класса переопределяется в наследниках, выбор метода на этапе выполнения.
Почему в Kotlin нужно писать open перед методом, который можно переопределить?
Ответ: В Kotlin все методы по умолчанию final (нельзя переопределить). Это сделано для производительности и безопасности. open — это явное разрешение на переопределение.
Что такое sealed класс и когда его использовать?
Ответ: Sealed класс — это класс, все наследники которого известны и объявлены в том же файле. Используется для моделирования конечных состояний (результаты операций, состояния загрузки, типы ошибок).
В чём преимущество data классов перед обычными классами?
Ответ: Data классы автоматически генерируют equals(), hashCode(), toString(), copy() и деструктуризацию. Это уменьшает количество шаблонного кода.
Как в Kotlin реализовать свойство только для чтения с кастомной логикой?
Ответ: Использовать val с кастомным геттером: val isAdult: Boolean get() = age >= 18. Значение вычисляется каждый раз при обращении.
Что такое композиция и чем она лучше наследования?
Ответ: Композиция — это когда объект содержит другие объекты как свои части. Она лучше наследования, потому что более гибкая: можно легко заменять компоненты, нет проблем с множественным наследованием, легче тестировать.
Как в Kotlin ограничить изменение свойства только внутри класса?
Ответ: Использовать private set: var age: Int = 0 private set. Геттер остаётся публичным, а сеттер — приватным.
Можно ли в Kotlin переопределить метод, не помеченный open?
Ответ: Нет. Компилятор выдаст ошибку. Нужно

← Vorherige OOP: Vererbung in Kotlin: Eine ausführliche Anleit Weiter → Fehler- und Ausnahmebehandlung in Kotlin: Eine aus