Kotlin 密封类 #

sealed class Result

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

fun handle(result: Result): String {
    return when (result) {
        is Success -> "Success: ${result.data}"
        is Error -> "Error: ${result.message}"
        Loading -> "Loading..."
    }
}

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

class ViewModel {
    private var state: UIState = UIState.Loading
    
    fun setState(newState: UIState) {
        state = newState
    }
    
    fun render(): String {
        return when (state) {
            is UIState.Loading -> "Loading..."
            is UIState.Success -> "Data: ${state.data}"
            is UIState.Error -> "Error: ${state.message}"
        }
    }
}

sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val code: Int, val message: String) : Result()
}

sealed class Permission {
    object Granted : Permission()
    object Denied : Permission()
}

sealed class Shape {
    class Circle(val radius: Double) : Shape()
    class Rectangle(val width: Double, val height: Double) : Shape()
}

sealed class Expr {
    data class Const(val number: Double) : Expr()
    data class Sum(val e1: Expr, val e2: Expr) : Expr()
    object NotANumber : Expr()
}

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

fun handle(result: Result): String = when (result) {
    is Result.Success -> "Success: ${result.data}"
    is Result.Error -> "Error: ${result.message}"
    // 不需要 else 分支，编译器会检查是否覆盖所有情况
}

sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
    object Loading : Result()  // 新增子类
}

fun handle(result: Result): String = when (result) {
    is Result.Success -> "Success: ${result.data}"
    is Result.Error -> "Error: ${result.message}"
    // 编译器会提示缺少 Loading 分支
}

sealed interface Action

object Start : Action
object Stop : Action
data class Execute(val command: String) : Action

sealed interface Shape {
    val area: Double
}

data class Circle(val radius: Double) : Shape {
    override val area: Double = Math.PI * radius * radius
}

data class Rectangle(val width: Double, val height: Double) : Shape {
    override val area: Double = width * height
}

sealed class NetworkState<out T> {
    object Idle : NetworkState<Nothing>()
    object Loading : NetworkState<Nothing>()
    data class Success<T>(val data: T) : NetworkState<T>()
    data class Error(val exception: Throwable) : NetworkState<Nothing>()
}

fun <T> handleState(state: NetworkState<T>) {
    when (state) {
        is NetworkState.Idle -> println("Idle")
        is NetworkState.Loading -> println("Loading...")
        is NetworkState.Success -> println("Success: ${state.data}")
        is NetworkState.Error -> println("Error: ${state.exception.message}")
    }
}

sealed class Expr {
    data class Const(val value: Double) : Expr()
    data class Sum(val left: Expr, val right: Expr) : Expr()
    data class Mul(val left: Expr, val right: Expr) : Expr()
    data class Div(val left: Expr, val right: Expr) : Expr()
}

fun eval(expr: Expr): Double = when (expr) {
    is Expr.Const -> expr.value
    is Expr.Sum -> eval(expr.left) + eval(expr.right)
    is Expr.Mul -> eval(expr.left) * eval(expr.right)
    is Expr.Div -> {
        val right = eval(expr.right)
        if (right != 0.0) eval(expr.left) / right else Double.NaN
    }
}

val expr = Expr.Sum(
    Expr.Const(1.0),
    Expr.Mul(Expr.Const(2.0), Expr.Const(3.0))
)
println(eval(expr))  // 7.0

sealed class PaymentMethod {
    data class CreditCard(
        val number: String,
        val expiryDate: String
    ) : PaymentMethod()
    
    data class PayPal(val email: String) : PaymentMethod()
    
    data class BankTransfer(
        val accountNumber: String,
        val routingNumber: String
    ) : PaymentMethod()
}

fun processPayment(method: PaymentMethod, amount: Double): String {
    return when (method) {
        is PaymentMethod.CreditCard -> 
            "Processing $amount via Credit Card ending in ${method.number.takeLast(4)}"
        is PaymentMethod.PayPal -> 
            "Processing $amount via PayPal (${method.email})"
        is PaymentMethod.BankTransfer -> 
            "Processing $amount via Bank Transfer"
    }
}

sealed class NavigationEvent {
    data class ToDetail(val id: Int) : NavigationEvent()
    data class ToProfile(val userId: String) : NavigationEvent()
    object Back : NavigationEvent()
    data class ToUrl(val url: String) : NavigationEvent()
}

fun navigate(event: NavigationEvent) {
    when (event) {
        is NavigationEvent.ToDetail -> 
            println("Navigate to detail: ${event.id}")
        is NavigationEvent.ToProfile -> 
            println("Navigate to profile: ${event.userId}")
        is NavigationEvent.Back -> 
            println("Go back")
        is NavigationEvent.ToUrl -> 
            println("Open URL: ${event.url}")
    }
}

enum class State {
    LOADING, SUCCESS, ERROR
}

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

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

// 使用密封类：有数据的状态
sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val code: Int) : Result()
}

// 推荐：状态后缀
sealed class UIState { }
sealed class NetworkResult { }

// 推荐：事件后缀
sealed class NavigationEvent { }

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

sealed class State {
    object Loading : State()
    object Idle : State()
    data class Data(val value: String) : State()
}