Kotlinの条件分岐でEnumクラスを効果的に活用する方法

enum class Season {
    SPRING, SUMMER, AUTUMN, WINTER
}

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

enum class Planet(val mass: Double, val radius: Double) {
    EARTH(5.97, 6371.0),
    MARS(0.642, 3389.5),
    JUPITER(1898.0, 69911.0)
}

enum class Status {
    SUCCESS {
        override fun getMessage() = "Operation was successful."
    },
    ERROR {
        override fun getMessage() = "An error occurred."
    };

    abstract fun getMessage(): String
}

fun main() {
    val currentStatus = Status.SUCCESS
    println(currentStatus.getMessage())  // 出力: Operation was successful.
}

enum class Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

fun getDayType(day: Day): String {
    return when (day) {
        Day.SATURDAY, Day.SUNDAY -> "週末"
        else -> "平日"
    }
}

fun main() {
    println(getDayType(Day.SATURDAY))  // 出力: 週末
    println(getDayType(Day.WEDNESDAY)) // 出力: 平日
}

enum class Status {
    SUCCESS, ERROR, LOADING
}

fun handleStatus(status: Status) {
    when (status) {
        Status.SUCCESS -> println("成功しました。")
        Status.ERROR -> println("エラーが発生しました。")
        Status.LOADING -> println("読み込み中です。")
    }
}

enum class AlertLevel(val severity: Int) {
    LOW(1), MEDIUM(2), HIGH(3)
}

fun handleAlert(level: AlertLevel) {
    when (level.severity) {
        1 -> println("低レベルの警告です。")
        2 -> println("中レベルの警告です。")
        3 -> println("高レベルの警告です。")
    }
}

fun main() {
    handleAlert(AlertLevel.HIGH)  // 出力: 高レベルの警告です。
}

enum class Status(val code: Int) {
    SUCCESS(200),
    ERROR(500),
    LOADING(102)
}

fun main() {
    println(Status.SUCCESS.code)  // 出力: 200
    println(Status.ERROR.code)    // 出力: 500
}

enum class AlertLevel(val severity: Int) {
    LOW(1) {
        override fun getDescription() = "低レベルの警告です。"
    },
    MEDIUM(2) {
        override fun getDescription() = "中レベルの警告です。"
    },
    HIGH(3) {
        override fun getDescription() = "高レベルの警告です。"
    };

    abstract fun getDescription(): String
}

fun main() {
    println(AlertLevel.LOW.getDescription())    // 出力: 低レベルの警告です。
    println(AlertLevel.HIGH.getDescription())   // 出力: 高レベルの警告です。
}

enum class HttpStatus(val code: Int, val message: String) {
    OK(200, "Success") {
        override fun isError() = false
    },
    BAD_REQUEST(400, "Bad Request") {
        override fun isError() = true
    },
    NOT_FOUND(404, "Not Found") {
        override fun isError() = true
    };

    abstract fun isError(): Boolean
}

fun main() {
    val status = HttpStatus.BAD_REQUEST
    println("Code: ${status.code}, Message: ${status.message}, Is Error: ${status.isError()}")
    // 出力: Code: 400, Message: Bad Request, Is Error: true
}

enum class UserRole {
    ADMIN,
    EDITOR,
    VIEWER
}

fun getAccessMessage(role: UserRole): String {
    return when (role) {
        UserRole.ADMIN -> "全ての操作が許可されています。"
        UserRole.EDITOR -> "コンテンツの編集が許可されています。"
        UserRole.VIEWER -> "閲覧のみが許可されています。"
    }
}

fun main() {
    println(getAccessMessage(UserRole.ADMIN))   // 出力: 全ての操作が許可されています。
    println(getAccessMessage(UserRole.EDITOR))  // 出力: コンテンツの編集が許可されています。
    println(getAccessMessage(UserRole.VIEWER))  // 出力: 閲覧のみが許可されています。
}

enum class LoadState {
    LOADING,
    SUCCESS,
    ERROR
}

fun displayStateMessage(state: LoadState) {
    when (state) {
        LoadState.LOADING -> println("データを読み込み中です...")
        LoadState.SUCCESS -> println("データの読み込みに成功しました！")
        LoadState.ERROR -> println("データの読み込みに失敗しました。")
    }
}

fun main() {
    displayStateMessage(LoadState.LOADING)  // 出力: データを読み込み中です...
    displayStateMessage(LoadState.SUCCESS)  // 出力: データの読み込みに成功しました！
    displayStateMessage(LoadState.ERROR)    // 出力: データの読み込みに失敗しました。
}

enum class PaymentMethod(val feePercentage: Double) {
    CREDIT_CARD(2.5),
    BANK_TRANSFER(1.0),
    CASH(0.0)
}

fun calculateTotalAmount(amount: Double, method: PaymentMethod): Double {
    return amount + (amount * method.feePercentage / 100)
}

fun main() {
    val amount = 1000.0
    println("クレジットカード支払い: ${calculateTotalAmount(amount, PaymentMethod.CREDIT_CARD)}円")
    println("銀行振込支払い: ${calculateTotalAmount(amount, PaymentMethod.BANK_TRANSFER)}円")
    println("現金支払い: ${calculateTotalAmount(amount, PaymentMethod.CASH)}円")
}

クレジットカード支払い: 1025.0円  
銀行振込支払い: 1010.0円  
現金支払い: 1000.0円  

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

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

enum class ConnectionState {
    CONNECTING,
    CONNECTED,
    DISCONNECTED
}

fun displayConnectionStatus(state: ConnectionState) {
    when (state) {
        ConnectionState.CONNECTING -> println("接続中...")
        ConnectionState.CONNECTED -> println("接続されました。")
        ConnectionState.DISCONNECTED -> println("切断されました。")
    }
}

fun main() {
    displayConnectionStatus(ConnectionState.CONNECTED)  // 出力: 接続されました。
}

enum class Priority {
    HIGH, MEDIUM, LOW
}

fun Priority.getDescription(): String {
    return when (this) {
        Priority.HIGH -> "高優先度のタスクです。"
        Priority.MEDIUM -> "中優先度のタスクです。"
        Priority.LOW -> "低優先度のタスクです。"
    }
}

fun main() {
    println(Priority.HIGH.getDescription())    // 出力: 高優先度のタスクです。
    println(Priority.LOW.getDescription())     // 出力: 低優先度のタスクです。
}

interface Describable {
    fun getDescription(): String
}

enum class VehicleType : Describable {
    CAR {
        override fun getDescription() = "自動車です。"
    },
    BIKE {
        override fun getDescription() = "バイクです。"
    },
    TRUCK {
        override fun getDescription() = "トラックです。"
    }
}

fun main() {
    println(VehicleType.CAR.getDescription())    // 出力: 自動車です。
    println(VehicleType.TRUCK.getDescription())  // 出力: トラックです。
}

enum class Color {
    RED, GREEN, BLUE
}

fun main() {
    // 定数を名前で検索
    val color = Color.valueOf("RED")
    println(color)  // 出力: RED

    // すべての定数を反復処理
    for (c in Color.values()) {
        println(c)
    }
}

RED  
RED  
GREEN  
BLUE  

enum class Mode {
    ACTIVE {
        override fun getStatus() = "モード: アクティブ"
    },
    INACTIVE,
    MAINTENANCE;

    open fun getStatus() = "モード: デフォルト"
}

fun main() {
    println(Mode.ACTIVE.getStatus())        // 出力: モード: アクティブ
    println(Mode.INACTIVE.getStatus())      // 出力: モード: デフォルト
    println(Mode.MAINTENANCE.getStatus())   // 出力: モード: デフォルト
}

enum class ErrorType(val message: String) {
    NETWORK_ERROR("ネットワーク接続に失敗しました。"),
    DATABASE_ERROR("データベース操作中にエラーが発生しました。"),
    AUTHENTICATION_ERROR("認証に失敗しました。"),
    UNKNOWN_ERROR("不明なエラーが発生しました。")
}

fun fetchDataFromServer(): ErrorType? {
    // 仮のエラー発生処理
    val isSuccess = false

    return if (isSuccess) {
        null  // 成功した場合はエラーなし
    } else {
        ErrorType.NETWORK_ERROR  // ネットワークエラーが発生
    }
}

fun main() {
    val error = fetchDataFromServer()
    if (error != null) {
        println("エラー: ${error.message}")  // 出力: エラー: ネットワーク接続に失敗しました。
    } else {
        println("データ取得に成功しました。")
    }
}

fun handleError(error: ErrorType) {
    when (error) {
        ErrorType.NETWORK_ERROR -> println("ネットワーク接続を確認してください。")
        ErrorType.DATABASE_ERROR -> println("データベース管理者に連絡してください。")
        ErrorType.AUTHENTICATION_ERROR -> println("ログイン情報を確認してください。")
        ErrorType.UNKNOWN_ERROR -> println("サポートにお問い合わせください。")
    }
}

fun main() {
    val error = ErrorType.AUTHENTICATION_ERROR
    handleError(error)  // 出力: ログイン情報を確認してください。
}

enum class ApiError(val code: Int, val description: String) {
    BAD_REQUEST(400, "不正なリクエストです。"),
    UNAUTHORIZED(401, "認証が必要です。"),
    NOT_FOUND(404, "リソースが見つかりません。"),
    INTERNAL_SERVER_ERROR(500, "サーバー内部エラーです。")
}

fun handleApiError(error: ApiError) {
    println("エラーコード: ${error.code}, 説明: ${error.description}")
}

fun main() {
    val error = ApiError.NOT_FOUND
    handleApiError(error)  // 出力: エラーコード: 404, 説明: リソースが見つかりません。
}