KotlinのEnumクラスにメソッドを定義する方法を徹底解説

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

fun main() {
    val today = Day.MONDAY
    println("Today is $today")
}

enum class Color {
    RED, GREEN, BLUE
}

fun main() {
    val favoriteColor = Color.GREEN
    println("My favorite color is $favoriteColor")
}

My favorite color is GREEN

enum class Color(val rgb: String) {
    RED("#FF0000"),
    GREEN("#00FF00"),
    BLUE("#0000FF")
}

fun main() {
    println("Red color code is ${Color.RED.rgb}")
    println("Green color code is ${Color.GREEN.rgb}")
}

Red color code is #FF0000  
Green color code is #00FF00

enum class Day {
    MONDAY, TUESDAY, WEDNESDAY
}

fun main() {
    val today = Day.WEDNESDAY
    println("Name: ${today.name}")
    println("Index: ${today.ordinal}")
}

Name: WEDNESDAY  
Index: 2

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

    fun getDescription(): String {
        return when (this) {
            NORTH -> "The direction is North."
            SOUTH -> "The direction is South."
            EAST  -> "The direction is East."
            WEST  -> "The direction is West."
        }
    }
}

fun main() {
    val direction = Direction.EAST
    println(direction.getDescription())
}

The direction is East.

enum class Operation {
    ADD {
        override fun calculate(a: Int, b: Int): Int = a + b
    },
    SUBTRACT {
        override fun calculate(a: Int, b: Int): Int = a - b
    },
    MULTIPLY {
        override fun calculate(a: Int, b: Int): Int = a * b
    };

    abstract fun calculate(a: Int, b: Int): Int
}

fun main() {
    val result = Operation.ADD.calculate(5, 3)
    println("Result: $result")
}

Result: 8

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

    fun surfaceGravity(): Double {
        val G = 6.67430e-11 // 万有引力定数
        return G * mass / (radius * radius)
    }
}

fun main() {
    println("Earth's surface gravity: ${Planet.EARTH.surfaceGravity()}")
    println("Mars' surface gravity: ${Planet.MARS.surfaceGravity()}")
}

Earth's surface gravity: 1.637911835e-10  
Mars' surface gravity: 5.597698149e-11

enum class Day(val isWeekend: Boolean) {
    MONDAY(false),
    TUESDAY(false),
    WEDNESDAY(false),
    THURSDAY(false),
    FRIDAY(false),
    SATURDAY(true),
    SUNDAY(true);
}

fun main() {
    for (day in Day.values()) {
        println("${day.name}: Is weekend? ${day.isWeekend}")
    }
}

MONDAY: Is weekend? false  
TUESDAY: Is weekend? false  
WEDNESDAY: Is weekend? false  
THURSDAY: Is weekend? false  
FRIDAY: Is weekend? false  
SATURDAY: Is weekend? true  
SUNDAY: Is weekend? true  

enum class Operation(val symbol: String) {
    ADD("+") {
        override fun calculate(a: Int, b: Int): Int = a + b
    },
    SUBTRACT("-") {
        override fun calculate(a: Int, b: Int): Int = a - b
    },
    MULTIPLY("*") {
        override fun calculate(a: Int, b: Int): Int = a * b
    },
    DIVIDE("/") {
        override fun calculate(a: Int, b: Int): Int = if (b != 0) a / b else throw ArithmeticException("Division by zero")
    };

    abstract fun calculate(a: Int, b: Int): Int
}

fun main() {
    val operation = Operation.ADD
    println("5 ${operation.symbol} 3 = ${operation.calculate(5, 3)}")
}

5 + 3 = 8

enum class Planet(val mass: Double, val radius: Double) {
    EARTH(5.97e24, 6.371e6),
    MARS(0.64171e24, 3.389e6),
    JUPITER(1.898e27, 7.149e7);

    fun surfaceGravity(): Double {
        val G = 6.67430e-11 // 万有引力定数
        return G * mass / (radius * radius)
    }
}

fun main() {
    for (planet in Planet.values()) {
        println("${planet.name}: Surface gravity = ${planet.surfaceGravity()} m/s^2")
    }
}

EARTH: Surface gravity = 9.798065154191442 m/s^2  
MARS: Surface gravity = 3.720763624111371 m/s^2  
JUPITER: Surface gravity = 24.793194763626882 m/s^2  

enum class HttpStatus(val code: Int, val description: String) {
    OK(200, "Success"),
    BAD_REQUEST(400, "Bad Request"),
    UNAUTHORIZED(401, "Unauthorized"),
    NOT_FOUND(404, "Not Found"),
    INTERNAL_SERVER_ERROR(500, "Internal Server Error");

    fun isSuccess(): Boolean {
        return this.code in 200..299
    }
}

fun main() {
    val status = HttpStatus.OK
    println("Code: ${status.code}, Description: ${status.description}")
    println("Is success? ${status.isSuccess()}")
}

Code: 200, Description: Success  
Is success? true  

enum class UserRole(val canEdit: Boolean, val canDelete: Boolean) {
    ADMIN(true, true),
    EDITOR(true, false),
    VIEWER(false, false);

    fun describePermissions(): String {
        return "Edit: $canEdit, Delete: $canDelete"
    }
}

fun main() {
    val role = UserRole.EDITOR
    println("User role: ${role.name}")
    println("Permissions: ${role.describePermissions()}")
}

User role: EDITOR  
Permissions: Edit: true, Delete: false  

enum class CalculatorOperation {
    ADD {
        override fun apply(a: Int, b: Int): Int = a + b
    },
    SUBTRACT {
        override fun apply(a: Int, b: Int): Int = a - b
    },
    MULTIPLY {
        override fun apply(a: Int, b: Int): Int = a * b
    },
    DIVIDE {
        override fun apply(a: Int, b: Int): Int = if (b != 0) a / b else throw ArithmeticException("Cannot divide by zero")
    };

    abstract fun apply(a: Int, b: Int): Int
}

fun main() {
    val operation = CalculatorOperation.MULTIPLY
    println("Result: ${operation.apply(6, 3)}")
}

Result: 18

enum class GameState {
    START {
        override fun message() = "Game is starting. Get ready!"
    },
    PLAYING {
        override fun message() = "Game is in progress. Have fun!"
    },
    GAME_OVER {
        override fun message() = "Game Over. Better luck next time!"
    };

    abstract fun message(): String
}

fun main() {
    val currentState = GameState.PLAYING
    println(currentState.message())
}

Game is in progress. Have fun!

enum class Operation {
    ADD {
        override fun apply(a: Int, b: Int): Int = a + b
    },
    SUBTRACT {
        override fun apply(a: Int, b: Int): Int = a - b
    },
    MULTIPLY {
        override fun apply(a: Int, b: Int): Int = a * b
    },
    DIVIDE {
        override fun apply(a: Int, b: Int): Int {
            if (b == 0) throw ArithmeticException("Division by zero")
            return a / b
        }
    };

    abstract fun apply(a: Int, b: Int): Int
}

fun main() {
    val operation = Operation.DIVIDE
    println("Result: ${operation.apply(10, 2)}")
}

Result: 5

enum class Animal(val sound: String) {
    DOG("Bark") {
        override fun action() = "Run and play"
    },
    CAT("Meow") {
        override fun action() = "Climb trees and sleep"
    },
    BIRD("Chirp") {
        override fun action() = "Fly high in the sky"
    };

    abstract fun action(): String
}

fun main() {
    for (animal in Animal.values()) {
        println("${animal.name}: Sound=${animal.sound}, Action=${animal.action()}")
    }
}

DOG: Sound=Bark, Action=Run and play  
CAT: Sound=Meow, Action=Climb trees and sleep  
BIRD: Sound=Chirp, Action=Fly high in the sky  

enum class TrafficLight {
    RED {
        override fun duration() = 30
        override fun action() = "Stop"
    },
    YELLOW {
        override fun duration() = 5
        override fun action() = "Slow down"
    },
    GREEN {
        override fun duration() = 45
        override fun action() = "Go"
    };

    abstract fun duration(): Int
    abstract fun action(): String
}

fun main() {
    for (light in TrafficLight.values()) {
        println("${light.name}: Duration=${light.duration()} seconds, Action=${light.action()}")
    }
}

RED: Duration=30 seconds, Action=Stop  
YELLOW: Duration=5 seconds, Action=Slow down  
GREEN: Duration=45 seconds, Action=Go  

interface Describable {
    fun description(): String
}

enum class VehicleType(val wheels: Int) : Describable {
    CAR(4) {
        override fun description() = "A car has $wheels wheels and is used for transportation."
    },
    BIKE(2) {
        override fun description() = "A bike has $wheels wheels and is suitable for short distances."
    },
    TRUCK(6) {
        override fun description() = "A truck has $wheels wheels and is used for carrying heavy loads."
    }
}

fun main() {
    for (type in VehicleType.values()) {
        println("${type.name}: ${type.description()}")
    }
}

CAR: A car has 4 wheels and is used for transportation.  
BIKE: A bike has 2 wheels and is suitable for short distances.  
TRUCK: A truck has 6 wheels and is used for carrying heavy loads.  

sealed class Status {
    object Success : Status()
    object Failure : Status()
    data class Error(val message: String) : Status()
}

fun getStatusDescription(status: Status): String {
    return when (status) {
        is Status.Success -> "Operation completed successfully."
        is Status.Failure -> "Operation failed."
        is Status.Error -> "Error occurred: ${status.message}"
    }
}

fun main() {
    val status1: Status = Status.Success
    val status2: Status = Status.Error("Network timeout")

    println(getStatusDescription(status1))
    println(getStatusDescription(status2))
}

Operation completed successfully.  
Error occurred: Network timeout  

enum class Currency(val country: String, val symbol: String) {
    USD("United States", "$"),
    EUR("European Union", "€"),
    JPY("Japan", "¥");

    fun format(amount: Double): String {
        return "$symbol$amount ($country)"
    }
}

fun main() {
    val amount = 100.0
    println(Currency.USD.format(amount))
    println(Currency.EUR.format(amount))
    println(Currency.JPY.format(amount))
}

$100.0 (United States)  
€100.0 (European Union)  
¥100.0 (Japan)  

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

fun Season.description(): String {
    return when (this) {
        Season.SPRING -> "Spring is warm and blooming."
        Season.SUMMER -> "Summer is hot and sunny."
        Season.FALL -> "Fall is cool and leaves change color."
        Season.WINTER -> "Winter is cold and snowy."
    }
}

fun main() {
    val currentSeason = Season.FALL
    println(currentSeason.description())
}

Fall is cool and leaves change color.

import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test

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

    fun description(): String {
        return when (this) {
            NORTH -> "Go up"
            SOUTH -> "Go down"
            EAST -> "Go right"
            WEST -> "Go left"
        }
    }
}

class DirectionTest {

    @Test
    fun `test direction descriptions`() {
        assertEquals("Go up", Direction.NORTH.description())
        assertEquals("Go down", Direction.SOUTH.description())
        assertEquals("Go right", Direction.EAST.description())
        assertEquals("Go left", Direction.WEST.description())
    }
}

import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.Test

enum class Status { START, RUNNING, STOPPED }

class StatusTest {

    @Test
    fun `test all statuses exist`() {
        val statuses = Status.values()
        assertTrue(statuses.contains(Status.START))
        assertTrue(statuses.contains(Status.RUNNING))
        assertTrue(statuses.contains(Status.STOPPED))
    }
}

enum class Level {
    LOW, MEDIUM, HIGH
}

fun main() {
    for (level in Level.values()) {
        println("Name: ${level.name}, Index: ${level.ordinal}")
    }
}

Name: LOW, Index: 0  
Name: MEDIUM, Index: 1  
Name: HIGH, Index: 2  

enum class Action {
    START, STOP, PAUSE
}

fun performAction(action: Action) {
    println("Performing action: ${action.name}")
}

fun main() {
    performAction(Action.PAUSE)
}

Performing action: PAUSE

import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows

enum class Operation {
    DIVIDE {
        fun calculate(a: Int, b: Int): Int {
            if (b == 0) throw ArithmeticException("Division by zero")
            return a / b
        }
    }
}

class OperationTest {

    @Test
    fun `test division by zero throws exception`() {
        val exception = assertThrows<ArithmeticException> {
            Operation.DIVIDE.calculate(5, 0)
        }
        assertEquals("Division by zero", exception.message)
    }
}