Kotlin 枚举类 #

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

val direction = Direction.NORTH

when (direction) {
    Direction.NORTH -> println("北")
    Direction.SOUTH -> println("南")
    Direction.EAST -> println("东")
    Direction.WEST -> println("西")
}

enum class Color(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF)
}

val red = Color.RED
println(red.rgb)  // 16711680

enum class Planet(
    val mass: Double,
    val radius: Double
) {
    EARTH(5.972e24, 6.371e6),
    MARS(6.39e23, 3.389e6),
    JUPITER(1.898e27, 6.9911e7);
    
    fun surfaceGravity(): Double {
        return 6.67e-11 * mass / (radius * radius)
    }
}

enum class Direction {
    NORTH, SOUTH, EAST, WEST;
    
    fun isVertical(): Boolean {
        return this == NORTH || this == SOUTH
    }
    
    fun opposite(): Direction {
        return when (this) {
            NORTH -> SOUTH
            SOUTH -> NORTH
            EAST -> WEST
            WEST -> EAST
        }
    }
}

Direction.NORTH.isVertical()  // true
Direction.NORTH.opposite()    // SOUTH

enum class Protocol {
    HTTP {
        override val port = 80
        override fun url(host: String) = "http://$host"
    },
    HTTPS {
        override val port = 443
        override fun url(host: String) = "https://$host"
    };
    
    abstract val port: Int
    abstract fun url(host: String): String
}

Protocol.HTTP.port       // 80
Protocol.HTTPS.url("example.com")  // https://example.com

enum class Color {
    RED, GREEN, BLUE
}

val color = Color.GREEN
color.name      // "GREEN"
color.ordinal   // 1

// 获取所有枚举值
val colors = Color.values()
// [RED, GREEN, BLUE]

// 根据名称获取枚举
val red = Color.valueOf("RED")

// Kotlin 1.9+ 使用 entries
val allColors = Color.entries

Color.values().forEach { color ->
    println("${color.name}: ${color.ordinal}")
}

// 或
for (color in Color.values()) {
    println(color)
}

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

fun getAngle(direction: Direction): Int = when (direction) {
    Direction.NORTH -> 0
    Direction.SOUTH -> 180
    Direction.EAST -> 90
    Direction.WEST -> 270
    // 不需要 else，编译器检查完整性
}

val description = when (direction) {
    Direction.NORTH -> "向北"
    Direction.SOUTH -> "向南"
    Direction.EAST -> "向东"
    Direction.WEST -> "向西"
}

interface Printable {
    fun print(): String
}

enum class Color : Printable {
    RED {
        override fun print() = "红色"
    },
    GREEN {
        override fun print() = "绿色"
    },
    BLUE {
        override fun print() = "蓝色"
    }
}

Color.RED.print()  // "红色"

interface Describable {
    fun describe(): String
}

enum class Priority : Describable {
    LOW, MEDIUM, HIGH;
    
    override fun describe(): String {
        return "Priority: $name"
    }
}

enum class HttpStatus(val code: Int, val message: String) {
    OK(200, "OK"),
    CREATED(201, "Created"),
    BAD_REQUEST(400, "Bad Request"),
    UNAUTHORIZED(401, "Unauthorized"),
    FORBIDDEN(403, "Forbidden"),
    NOT_FOUND(404, "Not Found"),
    INTERNAL_ERROR(500, "Internal Server Error");
    
    val isSuccess: Boolean
        get() = code in 200..299
    
    val isClientError: Boolean
        get() = code in 400..499
    
    val isServerError: Boolean
        get() = code in 500..599
}

HttpStatus.OK.isSuccess       // true
HttpStatus.NOT_FOUND.message  // "Not Found"

enum class Role(val permissions: List<String>) {
    ADMIN(listOf("read", "write", "delete", "manage")),
    MANAGER(listOf("read", "write", "manage")),
    USER(listOf("read", "write")),
    GUEST(listOf("read"));
    
    fun hasPermission(permission: String): Boolean {
        return permission in permissions
    }
}

Role.ADMIN.hasPermission("delete")  // true
Role.USER.hasPermission("manage")   // false

enum class OrderStatus {
    PENDING,
    CONFIRMED,
    PROCESSING,
    SHIPPED,
    DELIVERED,
    CANCELLED;
    
    fun canTransitionTo(newStatus: OrderStatus): Boolean {
        return when (this) {
            PENDING -> newStatus in listOf(CONFIRMED, CANCELLED)
            CONFIRMED -> newStatus in listOf(PROCESSING, CANCELLED)
            PROCESSING -> newStatus in listOf(SHIPPED, CANCELLED)
            SHIPPED -> newStatus == DELIVERED
            DELIVERED, CANCELLED -> false
        }
    }
}

OrderStatus.PENDING.canTransitionTo(OrderStatus.CONFIRMED)  // true
OrderStatus.SHIPPED.canTransitionTo(OrderStatus.CANCELLED)  // false

enum class LogLevel(val priority: Int) {
    VERBOSE(0),
    DEBUG(1),
    INFO(2),
    WARN(3),
    ERROR(4);
    
    fun shouldLog(minLevel: LogLevel): Boolean {
        return priority >= minLevel.priority
    }
}

LogLevel.ERROR.shouldLog(LogLevel.INFO)   // true
LogLevel.DEBUG.shouldLog(LogLevel.WARN)   // false

// 使用枚举：固定值，无复杂状态
enum class Direction { NORTH, SOUTH, EAST, WEST }

// 使用密封类：需要携带不同类型的数据
sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val code: Int, val message: String) : Result()
}

// 推荐
enum class HttpStatus { OK, NOT_FOUND }
enum class UserRole { ADMIN, USER }

// 不推荐
enum class Status { A, B, C }

enum class Priority {
    /** 低优先级 */
    LOW,
    /** 中优先级 */
    MEDIUM,
    /** 高优先级 */
    HIGH
}

// 推荐：when 表达式
fun handle(status: Status) = when (status) {
    Status.PENDING -> "Pending"
    Status.ACTIVE -> "Active"
    Status.COMPLETED -> "Completed"
}

// 不推荐：if-else 链
fun handle(status: Status): String {
    if (status == Status.PENDING) return "Pending"
    // ...
}