299 lines
12 KiB
Markdown
299 lines
12 KiB
Markdown
---
|
||
title: Enum class
|
||
description: Перечисления со свойствами и методами, entries, when по enum и его границы
|
||
tags:
|
||
- kotlin
|
||
- oop
|
||
---
|
||
|
||
`enum class` - класс с фиксированным набором экземпляров.
|
||
|
||
```kotlin
|
||
enum class Status { ACTIVE, BLOCKED, DELETED }
|
||
|
||
fun main() {
|
||
val s = Status.ACTIVE
|
||
println(s) // ACTIVE
|
||
println(s.name) // ACTIVE — строка
|
||
println(s.ordinal) // 0 — позиция в объявлении
|
||
}
|
||
```
|
||
|
||
## Свойства и конструктор
|
||
Каждая константа - вызов конструктора:
|
||
```kotlin
|
||
enum class Planet(val radiusKm: Int, val hasRings: Boolean) {
|
||
EARTH(6371, false),
|
||
SATURN(58232, true),
|
||
MARS(3390, false);
|
||
|
||
val radiusM: Int get() = radiusKm * 1000
|
||
fun describe() = "$name: радиус $radiusKm км, кольца=$hasRings"
|
||
}
|
||
|
||
fun main() {
|
||
println(Planet.SATURN.describe()) // SATURN: радиус 58232 км, кольца=true
|
||
println(Planet.EARTH.radiusM) // 6371000
|
||
}
|
||
```
|
||
Точка с запятой после последней константы обязательна, если дальше идёт тело класса.
|
||
|
||
## Методы в константах
|
||
Константа может переопределить метод - это заменяет `when` по самой себе:
|
||
```kotlin
|
||
enum class Operation {
|
||
PLUS { override fun apply(a: Int, b: Int) = a + b },
|
||
MINUS { override fun apply(a: Int, b: Int) = a - b },
|
||
TIMES { override fun apply(a: Int, b: Int) = a * b };
|
||
|
||
abstract fun apply(a: Int, b: Int): Int
|
||
}
|
||
|
||
fun main() {
|
||
println(Operation.PLUS.apply(2, 3)) // 5
|
||
println(Operation.TIMES.apply(2, 3)) // 6
|
||
println(Operation.entries.joinToString { "${it.name}=${it.apply(6, 3)}" })
|
||
// PLUS=9, MINUS=3, TIMES=18
|
||
}
|
||
```
|
||
Каждая такая константа компилируется в анонимный подкласс.
|
||
|
||
## Реализация интерфейса
|
||
```kotlin
|
||
interface Describable { fun describe(): String }
|
||
|
||
enum class Level(val weight: Int) : Describable {
|
||
LOW(1), HIGH(10);
|
||
|
||
override fun describe() = "$name (вес $weight)"
|
||
}
|
||
|
||
fun main() {
|
||
val items: List<Describable> = Level.entries
|
||
println(items.joinToString { it.describe() }) // LOW (вес 1), HIGH (вес 10)
|
||
}
|
||
```
|
||
|
||
## entries, values, valueOf
|
||
```kotlin
|
||
enum class Status { ACTIVE, BLOCKED }
|
||
|
||
fun main() {
|
||
println(Status.entries) // [ACTIVE, BLOCKED] — список
|
||
println(Status.entries.size) // 2
|
||
println(Status.valueOf("ACTIVE")) // ACTIVE
|
||
println(Status.entries.first().name) // ACTIVE
|
||
// println(Status.valueOf("НЕТ")) // IllegalArgumentException
|
||
}
|
||
```
|
||
|
||
`entries` (Kotlin 1.9+) заменяет `values()`. Разница практическая:
|
||
|
||
| | `values()` | `entries` |
|
||
|---|---|---|
|
||
| тип | `Array<Status>` | `EnumEntries<Status>` (это `List`) |
|
||
| аллокация | **новый массив при каждом вызове** | один неизменяемый список |
|
||
| изменяемость | элементы можно подменить | нельзя |
|
||
|
||
```kotlin
|
||
enum class Status { ACTIVE, BLOCKED }
|
||
|
||
fun main() {
|
||
@Suppress("DEPRECATION")
|
||
println(Status.values().contentToString()) // [ACTIVE, BLOCKED]
|
||
println(Status.entries) // [ACTIVE, BLOCKED]
|
||
}
|
||
```
|
||
В новом коде всегда `entries`.
|
||
|
||
Безопасный разбор строки:
|
||
```kotlin
|
||
enum class Status { ACTIVE, BLOCKED }
|
||
|
||
fun parseStatus(s: String): Status? =
|
||
Status.entries.find { it.name == s }
|
||
|
||
fun main() {
|
||
println(parseStatus("ACTIVE")) // ACTIVE
|
||
println(parseStatus("нет")) // null — без исключения
|
||
}
|
||
```
|
||
Через `enumValueOf` то же самое, но с исключением. Для внешних данных (JSON, БД, параметры запроса) нужна версия с `null`.
|
||
|
||
## when по enum
|
||
Главное применение. Компилятор проверяет полноту, и `else` не нужен:
|
||
```kotlin
|
||
enum class Status { ACTIVE, BLOCKED, DELETED }
|
||
|
||
fun message(s: Status): String = when (s) {
|
||
Status.ACTIVE -> "работает"
|
||
Status.BLOCKED -> "заблокирован"
|
||
Status.DELETED -> "удалён"
|
||
}
|
||
|
||
fun main() {
|
||
println(message(Status.BLOCKED)) // заблокирован
|
||
}
|
||
```
|
||
Если добавить константу `ARCHIVED`, этот `when` перестанет компилироваться - компилятор найдёт все места, которые нужно обновить. Поэтому `else` в `when` по enum - вредная привычка: он скрывает именно те ошибки, от которых enum защищает.
|
||
|
||
Импорт констант сокращает запись:
|
||
```kotlin
|
||
enum class Status { ACTIVE, BLOCKED }
|
||
|
||
fun message(s: Status): String {
|
||
return when (s) {
|
||
Status.ACTIVE -> "работает"
|
||
Status.BLOCKED -> "заблокирован"
|
||
}
|
||
}
|
||
|
||
fun main() = println(message(Status.ACTIVE))
|
||
```
|
||
|
||
## Сравнение и порядок
|
||
```kotlin
|
||
enum class Level { LOW, MEDIUM, HIGH }
|
||
|
||
fun main() {
|
||
println(Level.LOW == Level.LOW) // true
|
||
println(Level.LOW < Level.HIGH) // true — по ordinal
|
||
println(Level.entries.sorted()) // [LOW, MEDIUM, HIGH]
|
||
println(Level.HIGH.ordinal) // 2
|
||
println(Level.entries.maxOf { it.ordinal }) // 2
|
||
}
|
||
```
|
||
`enum` реализует `Comparable` по `ordinal`. Сравнивать через `==` безопасно: экземпляр единственный, поэтому `==` и `===` дают одно и то же.
|
||
|
||
## EnumMap и EnumSet
|
||
Специализированные коллекции для enum - массив вместо хеш-таблицы:
|
||
```kotlin
|
||
import java.util.EnumMap
|
||
import java.util.EnumSet
|
||
|
||
enum class Day { MON, TUE, WED }
|
||
|
||
fun main() {
|
||
val hours = EnumMap<Day, Int>(Day::class.java)
|
||
hours[Day.MON] = 8
|
||
hours[Day.TUE] = 6
|
||
println(hours) // {MON=8, TUE=6}
|
||
|
||
val workdays = EnumSet.of(Day.MON, Day.TUE)
|
||
println(workdays.contains(Day.WED)) // false
|
||
println(EnumSet.complementOf(workdays)) // [WED]
|
||
}
|
||
```
|
||
Это классы JDK; в stdlib Kotlin аналогов нет. Для небольших enum разница с `HashMap` несущественна.
|
||
|
||
## companion object
|
||
```kotlin
|
||
enum class Status(val code: Int) {
|
||
ACTIVE(1), BLOCKED(2);
|
||
|
||
companion object {
|
||
private val byCode = entries.associateBy { it.code }
|
||
fun fromCode(code: Int): Status? = byCode[code]
|
||
}
|
||
}
|
||
|
||
fun main() {
|
||
println(Status.fromCode(2)) // BLOCKED
|
||
println(Status.fromCode(99)) // null
|
||
}
|
||
```
|
||
Поиск по коду через заранее построенную `Map` - стандартный приём. Подробнее: [Object и companion object](Object%20и%20companion%20object.md)
|
||
|
||
## Когда enum, а когда sealed
|
||
```kotlin
|
||
enum class Status { OK, ERROR } // варианты без данных
|
||
|
||
sealed interface Result2
|
||
data class Ok(val value: Int) : Result2 // варианты с разными данными
|
||
data class Error(val message: String) : Result2
|
||
```
|
||
`enum` - фиксированный набор **значений**, у всех одинаковая структура. `sealed` - фиксированный набор **типов**, у каждого свои свойства. Подробнее: [Sealed class и interface](Sealed%20class%20и%20interface.md)
|
||
|
||
> [!info] Отличия от Java
|
||
> | Java | Kotlin |
|
||
> |---|---|
|
||
> | `enum Status { ACTIVE }` | `enum class Status { ACTIVE }` |
|
||
> | `Status.values()` | `Status.entries` |
|
||
> | `Status.valueOf(s)` | `Status.valueOf(s)` или `entries.find` |
|
||
> | `switch` без проверки полноты до Java 21 | `when` проверяет всегда |
|
||
> | `EnumMap`/`EnumSet` | то же (из JDK) |
|
||
>
|
||
> Устройство одинаковое - на JVM это тот же `java.lang.Enum`. Два практических различия:
|
||
>
|
||
> **`entries` вместо `values()`.** Java-метод `values()` возвращает новый массив при каждом вызове, потому что массив изменяем и вернуть общий нельзя. `entries` возвращает неизменяемый список, поэтому экземпляр один. В цикле это заметная разница.
|
||
>
|
||
> **Проверка полноты.** В Java `switch` по enum без `default` долго не проверялся: добавление константы молча менялo поведение. Kotlin проверяет `when`-выражение с момента появления языка, а с Kotlin 2.0 - и `when`-инструкцию.
|
||
>
|
||
> Сравнить: [Enum в Java](../../../Программирование%20на%20Java/Синтаксис%20и%20типы/Базовые%20типы%20ООП/Enum.md)
|
||
|
||
> [!warning] Подводные камни
|
||
> **`ordinal` нельзя сохранять в БД или в файл.** Он меняется при вставке константы в середину:
|
||
> ```kotlin
|
||
> enum class Status { ACTIVE, BLOCKED } // BLOCKED.ordinal == 1
|
||
> // добавили NEW в середину:
|
||
> // enum class Status { ACTIVE, NEW, BLOCKED } // BLOCKED.ordinal == 2
|
||
> ```
|
||
> Все сохранённые единицы станут означать `NEW`. Для сериализации используйте `name` или свой стабильный `code`.
|
||
>
|
||
> **`name` тоже хрупок при переименовании** - но его хотя бы нельзя изменить случайно. Самый надёжный вариант - явное свойство:
|
||
> ```kotlin
|
||
> enum class Status(val code: String) {
|
||
> ACTIVE("active"), BLOCKED("blocked")
|
||
> }
|
||
>
|
||
> fun main() { println(Status.ACTIVE.code) } // active
|
||
> ```
|
||
>
|
||
> **`valueOf` бросает исключение на незнакомой строке**, а не возвращает `null`. Для внешних данных нужна своя обёртка через `entries.find`.
|
||
>
|
||
> **`values()` аллоцирует массив на каждый вызов:**
|
||
> ```kotlin
|
||
> enum class Status { ACTIVE }
|
||
>
|
||
> fun main() {
|
||
> @Suppress("DEPRECATION")
|
||
> repeat(3) { Status.values() } // три разных массива
|
||
> repeat(3) { Status.entries } // один и тот же список
|
||
> println("ok")
|
||
> }
|
||
> ```
|
||
>
|
||
> **`else` в `when` по enum отключает проверку полноты.** Самая частая ошибка: добавили константу, компилятор промолчал, в рантайме сработала ветка `else`.
|
||
>
|
||
> **Enum нельзя наследовать и расширять.** Если набор вариантов должен быть расширяемым (например, плагинами), enum не подходит - нужен `sealed interface` или обычная иерархия.
|
||
>
|
||
> **Enum с изменяемым состоянием - глобальная переменная:**
|
||
> ```kotlin
|
||
> enum class Counter {
|
||
> INSTANCE;
|
||
> var count = 0 // общее состояние на всю программу
|
||
> }
|
||
>
|
||
> fun main() {
|
||
> Counter.INSTANCE.count++
|
||
> println(Counter.INSTANCE.count) // 1 — и так во всех потоках
|
||
> }
|
||
> ```
|
||
> Константы enum - синглтоны, поэтому `var` в них небезопасен при многопоточности.
|
||
>
|
||
> **`when` по nullable enum всё равно требует `else` или ветки `null`:**
|
||
> ```kotlin
|
||
> enum class Status { ACTIVE, BLOCKED }
|
||
>
|
||
> fun message(s: Status?): String = when (s) {
|
||
> Status.ACTIVE -> "работает"
|
||
> Status.BLOCKED -> "заблокирован"
|
||
> null -> "не задан"
|
||
> }
|
||
>
|
||
> fun main() { println(message(null)) } // не задан
|
||
> ```
|
||
|
||
Дополнительно: [Sealed class и interface](Sealed%20class%20и%20interface.md)
|
||
Далее: [Sealed class и interface](Sealed%20class%20и%20interface.md)
|