枚举类最基本的用法是实现一个类型安全的枚举。 
  1. enum class Direction {
  2.     NORTH, SOUTH, WEST, EAST
  3. }
枚举常量用逗号分隔,每个枚举常量都是一个对象。

枚举初始化

每一个枚举都是枚举类的实例，它们可以被初始化： 
  1. enum class Color(val rgb: Int) {
  2.     RED(0xFF0000),
  3.     GREEN(0x00FF00),
  4.     BLUE(0x0000FF)
  5. }
默认名称为枚举字符名，值从0开始。若需要指定值，则可以使用其构造函数： 
  2. enum class Shape(value:Int){
  3.     ovel(100),
  4.     rectangle(200)
  5. }
  7. fun main() {
  8.     for (f in Shape.values()) {
  9.         println("$f = ${f.ordinal}")
  10.     }
  11. }
  13. /* 
  14. ovel = 0
  15. rectangle = 1
  16. */

匿名类

枚举常量可以声明其带有相应方法以及覆盖了基类方法的自身匿名类 。如：

  1. enum class ProtocolState {
  2.     WAITING {
  3.         override fun signal() = 1
  4.     },
  6.     TALKING {
  7.         override fun signal() = 2
  8.     };
  10.     abstract fun signal(): Int
  11. }
  13. fun main() {
  14.     for (f in ProtocolState.values()) {
  15.         println("$f = f.name(${f.name})-f.ordinal(${f.ordinal})-f.signal()(${f.signal()})")
  16.     }
  17. }
  19. /* 
  20. WAITING = f.name(WAITING)-f.ordinal(0)-f.signal()(1)
  21. TALKING = f.name(TALKING)-f.ordinal(1)-f.signal()(2)
  22. */

如果枚举类定义任何成员，那么使用分号将成员定义与常量定义分隔开。

在枚举类中实现接口

一个枚举类可以实现接口（但不能从类继承）

可以为所有条目提供统一的接口成员实现，也可以在相应匿名类中为每个条目提供各自的实现。 只需将想要实现的接口添加到枚举类声明中即可，如下所示：

  1. import java.util.function.BinaryOperator
  2. import java.util.function.IntBinaryOperator
  4. enum class IntArithmetics : BinaryOperator<Int>, IntBinaryOperator {
  5.     PLUS {
  6.         override fun apply(t: Int, u: Int): Int = t + u
  7.     },
  8.     TIMES {
  9.         override fun apply(t: Int, u: Int): Int = t * u
  10.     };
  12.     override fun applyAsInt(t: Int, u: Int) = apply(2, 2)
  13. }
  15. fun main() {
  16.     val a = 13
  17.     val b = 31
  18.     for (f in IntArithmetics.values()) {
  19.         println("$f($a, $b) = ${f.apply(a, b)}")
  20.     }
  21. }
  23. /* 
  24. PLUS(13, 31) = 44
  25. TIMES(13, 31) = 403 
  26. */

使用枚举常量

Kotlin 中的枚举类具有合成方法，允许遍历定义的枚举常量，并通过其名称获取枚举常数。 
  1. EnumClass.valueOf(value: String): EnumClass  // 转换指定 name 为枚举值，若未匹配成功，会抛出IllegalArgumentException
  2. EnumClass.values(): Array<EnumClass>        // 以数组的形式，返回枚举值
获取枚举相关信息： 
  1. val name: String //获取枚举名称
  2. val ordinal: Int //获取枚举值在所有枚举数组中定义的顺序

枚举常量还实现了 Comparable 接口， 其中自然顺序是它们在枚举类中定义的顺序。

实例

  1. enum class Color{
  2.     RED,BLACK,BLUE,GREEN,WHITE
  3. }
  5. fun main(args: Array<String>) {
  6.     var color:Color=Color.BLUE
  8.     println(Color.values())
  9.     println(Color.valueOf("RED"))
  10.     println(color.name)
  11.     println(color.ordinal)
  12. }
  14. /* 
  15. [LColor;@1b6d3586
  16. RED
  17. BLUE
  18. 2 
  19. */

自 Kotlin 1.1 起，可以使用 enumValues() 和 enumValueOf() 函数以泛型的方式访问枚举类中的常量 ：

  1. enum class RGB { RED, GREEN, BLUE }
  3. inline fun <reified T : Enum<T>> printAllValues() {
  4.     print(enumValues<T>().joinToString { "${it.name}(${it.ordinal})" })
  5. }
  8. fun main(args: Array<String>) {
  9.     printAllValues<RGB>()
  10. }
  12. /* 
  13. RED(0), GREEN(1), BLUE(2)
  14. */