Какие знаешь виды классов в Kotlin?

Виды классов в Kotlin

Kotlin, будучи современным языком на JVM, предоставляет богатый набор типов классов и структур для разных целей. Каждый вид класса имеет специфическое назначение и особенности использования.

1. Обычный класс (Regular Class)

Основной тип класса в Kotlin. По умолчанию final (нельзя наследоваться), если явно не добавлен модификатор open.

class Person(val name: String, val age: Int) {
    fun greet() {
        println("Hello, I am $name")
    }
}

// Использование
val person = Person("Alice", 30)
person.greet()

Особенности:

• По умолчанию final (нельзя наследовать)
• Конструктор можно объявить в заголовке класса
• Автоматически создаётся метод equals, hashCode, toString

Open класс для наследования

open class Animal(val name: String) {  // open разрешает наследование
    open fun makeSound() {
        println("Some generic sound")
    }
}

class Dog(name: String) : Animal(name) {
    override fun makeSound() {
        println("Woof!")
    }
}

2. Data классы (Data Classes)

Классы, предназначенные для хранения данных. Компилятор автоматически генерирует equals(), hashCode(), toString(), copy() и componentN().

data class User(val id: Int, val name: String, val email: String) {
    // Автоматически генерируется:
    // - equals() и hashCode()
    // - toString() в формате User(id=1, name=Alice, email=a@test.com)
    // - copy(id, name, email)
    // - componentN() для деструктуризации
}

val user1 = User(1, "Alice", "alice@test.com")
val user2 = User(1, "Alice", "alice@test.com")

// equals работает по значению
println(user1 == user2)  // true

// copy() с частичной переассигнацией
val user3 = user1.copy(name = "Bob")

// Деструктуризация
val (id, name, email) = user1

Требования для data классов:

• Основной конструктор должен иметь минимум одно свойство
• Все свойства должны быть val или var
• Не может быть abstract, sealed или inner

3. Sealed классы (Sealed Classes)

Абстрактные классы, которые ограничивают наследование только заранее определёнными подклассами. Отлично подходят для представления закрытых иерархий типов.

sealed class Result<out T> {
    data class Success<T>(val data: T) : Result<T>()
    data class Error(val exception: Exception) : Result<Nothing>()
    object Loading : Result<Nothing>()
}

// Использование с when (compiler гарантирует exhaustive match)
fun handleResult(result: Result<String>) {
    when (result) {
        is Result.Success -> println("Data: ${result.data}")
        is Result.Error -> println("Error: ${result.exception.message}")
        is Result.Loading -> println("Loading...")
    }
}

Преимущества:

• Compiler гарантирует exhaustive when
• Безопас для представления ADT (Algebraic Data Types)
• Можно ограничить расширение только внутри файла или пакета

4. Enum классы (Enum Classes)

Классы, представляющие перечисление фиксированного набора значений. Каждый enum-value — это экземпляр класса.

enum class Direction {
    NORTH, SOUTH, EAST, WEST
}

// С дополнительными свойствами и методами
enum class Color(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF);
    
    fun isWarmColor(): Boolean = this == RED || this == GREEN
}

// Использование
val color = Color.RED
println(color.rgb)              // 0xFF0000
println(color.isWarmColor())    // true
println(Color.values())         // [RED, GREEN, BLUE]
println(Color.valueOf("RED"))   // RED

Особенности:

• Все значения — синглтоны
• Автоматически наследуют java.lang.Enum
• Поддерживают свойства, конструкторы, методы

5. Interface (Интерфейсы)

Контракты для классов. В Kotlin интерфейсы могут содержать реализацию методов и свойств.

interface Drawable {
    fun draw()  // Абстрактный метод
    
    fun describe() {  // Метод с реализацией по умолчанию
        println("This is a drawable object")
    }
}

interface Colorable {
    val color: String  // Абстрактное свойство
}

class Circle : Drawable, Colorable {
    override val color: String = "Red"
    
    override fun draw() {
        println("Drawing a circle")
    }
}

6. Inner классы (Вложенные классы)

Nested класс (статический)

class Outer {
    class Nested {  // По умолчанию статический (как static в Java)
        fun test() {
            // Не имеет доступа к членам Outer
        }
    }
}

// Использование
Outer.Nested().test()

Inner класс (нестатический)

class Outer {
    val outerProperty = "outer"
    
    inner class Inner {  // Явно нужен inner
        fun test() {
            println(outerProperty)  // Доступ к членам Outer
            println(this@Outer)     // Явное обращение к Outer
        }
    }
}

// Использование
Outer().Inner().test()

7. Anonymous классы (Анонимные классы)

val obj = object : Drawable {
    override fun draw() {
        println("Drawing anonymously")
    }
}

// SAM (Single Abstract Method) функции автоматически конвертируются
val button = Button().apply {
    setOnClickListener { println("Clicked") }
}

8. Object выражения и Singleton

Object для синглтона

object DatabaseConfig {  // Автоматически синглтон
    val url = "jdbc:postgresql://localhost/db"
    val username = "user"
    
    fun connect() {
        println("Connecting to $url")
    }
}

// Использование
DatabaseConfig.connect()

Companion object

class User {
    val name: String = ""
    
    companion object {  // Статические члены класса
        fun create(id: Int): User {
            return User()
        }
        
        const val DEFAULT_NAME = "Anonymous"
    }
}

// Использование
val user = User.create(1)
println(User.DEFAULT_NAME)

9. Abstract классы (Абстрактные классы)

abstract class Vehicle(val brand: String) {
    abstract fun start()
    abstract fun stop()
    
    fun describe() {  // Конкретный метод
        println("This is a $brand vehicle")
    }
}

class Car(brand: String) : Vehicle(brand) {
    override fun start() {
        println("Starting car engine...")
    }
    
    override fun stop() {
        println("Stopping car engine...")
    }
}

10. Value классы (Inline классы) — новое в Kotlin 1.5

Легковесные обертки над типом, которые компилятор может оптимизировать.

@JvmInline
value class UserId(val id: Long) {
    fun isValid() = id > 0
}

// Использование
val userId = UserId(123L)
println(userId.isValid())

// На уровне компилятора это просто Long, без упаковки

Сравнительная таблица

Тип           | Наследование | Data | Синглтон | Абстрактный
---|---|---|---|---
Regular       | Можно        | Нет  | Нет      | Нет
Data          | Можно        | Да   | Нет      | Нет
Sealed        | Ограничено   | Нет  | Нет      | Да
Enum          | Нет          | Нет  | Да       | Да
Abstract      | Можно        | Нет  | Нет      | Да
Interface     | Можно        | Нет  | Нет      | Да
Object        | Нет          | Нет  | Да       | Нет
Inner         | Можно        | Нет  | Нет      | Нет
Nested        | Можно        | Нет  | Нет      | Нет

Рекомендации

1. Используй data классы для моделей данных
2. Sealed классы для представления закрытых иерархий (как в functional programming)
3. Enum классы для ограниченного набора значений
4. Object для синглтонов и конфигурации
5. Interface для контрактов и множественного наследования
6. Abstract классы когда нужно состояние или конструктор
7. Избегай inner классов если можно обойтись nested

Выбор правильного вида класса делает код более безопасным, читаемым и эффективным на JVM.