MENU
  1. ホーム
  2. Kotlin
  3. Kotlinのsealedクラスを使った階層構造の設計方法と実装例

Kotlinのsealedクラスを使った階層構造の設計方法と実装例

Kotlin

Kotlinのsealedクラスを使った階層構造の設計は、柔軟で安全なコードを書くための強力な手法です。階層構造とは、関連するデータや状態を一つのグループとして整理し、特定の条件下で異なる動作や情報を持たせる設計方法です。

例えば、複数の状態やイベントを定義する場合、sealedクラスを使用することでコンパイル時の安全性を確保しつつ、コードの可読性や保守性を高めることができます。

本記事では、Kotlinのsealedクラスの基本概念から、実際の実装方法、階層構造を効率的に設計する手法、応用例までを詳しく解説します。さらに、状態管理やパターンマッチングといった具体的なシナリオも取り上げることで、Kotlinのsealedクラスを最大限に活用するための知識を習得できます。

目次

Sealedクラスとは何か


Kotlinのsealedクラスは、継承の範囲を限定するための特殊なクラスです。特定の親クラスから派生する子クラスを、あらかじめ制限したい場合に使用します。これにより、コンパイル時にクラスの状態や種類を把握できるため、型安全性が高まり、パターンマッチングが容易になります。

Sealedクラスの役割

  1. 型安全な階層構造の定義
    Sealedクラスを使うことで、子クラスの定義を限定し、型ごとの処理を安全に記述できます。
  2. when式との相性の良さ
    when式と組み合わせることで、すべてのケースが網羅されているかコンパイル時にチェックされます。
  3. 拡張性の確保
    子クラスを同一ファイル内に限定するため、クラスの拡張が明示的になります。

Sealedクラスの基本ルール

  • sealedキーワードを使ってクラスを宣言する。
  • Sealedクラスの子クラスは同じファイル内に定義する必要がある。
  • Sealedクラス自体は抽象クラス（abstract）として機能する。

シンプルな例


以下は、Sealedクラスを用いて複数の状態を表現する例です。

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

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

Sealedクラスの使用場面

  • 状態管理: ロード中・成功・エラーといったUI状態の管理。
  • イベントの管理: イベントの種類を限定して処理する。
  • APIレスポンスの型分け: サーバーからのデータが複数の結果を返す際に利用。

Sealedクラスは、Kotlinにおいて階層構造を簡潔かつ安全に設計するための便利な手段です。

階層構造設計にSealedクラスを使う理由


KotlinのSealedクラスは、階層構造を安全かつシンプルに設計するための強力なツールです。特に、状態やイベントの種類が明確で数が限定されている場合に効果を発揮します。以下に、Sealedクラスが階層構造設計に適している理由を説明します。

1. 型安全性の向上


Sealedクラスを使用することで、子クラスの種類がコンパイル時に固定されます。これにより、when式を使用した際に、すべての分岐が網羅されているかをコンパイラがチェックしてくれます。

例

sealed class Response
data class Success(val data: String) : Response()
data class Failure(val error: String) : Response()

fun handleResponse(response: Response) {
    when (response) {
        is Success -> println("Success: ${response.data}")
        is Failure -> println("Error: ${response.error}")
    }
}

上記の例では、Responseクラスの子クラスはSuccessとFailureのみです。もしwhen式でこれらの分岐が網羅されていなければ、コンパイルエラーになります。

2. コードの可読性と保守性


Sealedクラスは、関連するデータや状態を一箇所にまとめることで、コードの構造が明確になります。階層構造がシンプルに表現され、チームでの開発やコードレビューも容易になります。

3. 拡張が制限される


Sealedクラスの子クラスは、同じファイル内に定義される必要があります。この制限により、意図しないクラスの拡張や不具合の原因となるクラス追加を防止できます。

4. 状態管理のシンプル化


アプリケーションの状態管理において、Sealedクラスは複数の状態を安全に表現するのに役立ちます。例えば、UIの状態（ロード中・成功・エラー）をSealedクラスでシンプルに管理できます。

例

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

5. データの一貫性を確保


Sealedクラスを使えば、複数の状態や型が一貫して管理され、ロジックの分岐やデータ操作が冗長になりません。

まとめ


Sealedクラスは、型安全性を高め、コードの可読性や保守性を向上させるため、階層構造設計に最適です。特に状態管理やイベントの種類が限定されている場面では、その利便性が最大限に発揮されます。

Sealedクラスの基本的な書き方


KotlinにおけるSealedクラスの基本的な書き方を解説します。Sealedクラスを使うことで、関連するクラスをまとめ、継承関係を制限しつつ型安全なコードを記述できます。以下のルールとコード例を通じて基本的な使い方を理解しましょう。

Sealedクラスの基本ルール

  1. sealedキーワードを使ってクラスを宣言する。
  2. Sealedクラスの子クラスは同じファイル内で定義する必要がある。
  3. Sealedクラス自体は抽象クラス（abstract）として動作し、インスタンス化できない。
  4. when式との組み合わせにより、型安全な分岐処理が可能。

シンプルなSealedクラスの例


以下の例では、APIのレスポンスを表現するためにSealedクラスを利用しています。

sealed class ApiResponse

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

fun handleResponse(response: ApiResponse) {
    when (response) {
        is Success -> println("Data received: ${response.data}")
        is Error -> println("Error occurred: ${response.message}")
        Loading -> println("Loading...")
    }
}

コードの解説

  • sealedキーワード：ApiResponseはSealedクラスとして宣言されています。
  • 子クラス：SuccessとErrorはデータクラス、Loadingはシングルトンオブジェクトとして定義されています。
  • when式：whenを使ってApiResponseの子クラスごとに分岐処理を行っています。すべての分岐が網羅されていなければ、コンパイルエラーになります。

Sealedクラスの階層構造の例


より複雑な階層を表現する場合、Sealedクラスを以下のように構築できます。

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

fun calculateArea(shape: Shape): Double {
    return when (shape) {
        is Shape.Circle -> 3.14 * shape.radius * shape.radius
        is Shape.Rectangle -> shape.width * shape.height
        is Shape.Triangle -> 0.5 * shape.base * shape.height
    }
}

fun main() {
    val circle = Shape.Circle(5.0)
    val rectangle = Shape.Rectangle(4.0, 6.0)
    val triangle = Shape.Triangle(4.0, 5.0)

    println("Circle Area: ${calculateArea(circle)}")
    println("Rectangle Area: ${calculateArea(rectangle)}")
    println("Triangle Area: ${calculateArea(triangle)}")
}

ポイント

  • 階層構造：SealedクラスShapeは、Circle、Rectangle、Triangleという子クラスを持ち、それぞれ異なるデータを保持しています。
  • 型安全な処理：calculateArea関数ではwhen式を用いて、各子クラスに対する処理を安全に記述しています。

Sealedクラスと抽象クラスの違い

項目Sealedクラス抽象クラス
子クラスの定義同じファイル内のみ任意のファイルで定義可能
継承の制限子クラスの種類がコンパイル時に確定制限なし
型安全性when式で全ケース網羅チェックが行われる網羅チェックはされない

まとめ


Sealedクラスは、関連するクラスを一つのグループとしてまとめ、型安全かつ明確な階層構造を提供します。基本的な書き方を理解し、when式と組み合わせることで、安全で拡張性の高いコードを実装できます。

データクラスとSealedクラスの組み合わせ


Kotlinでは、Sealedクラスとデータクラスを組み合わせることで、柔軟で型安全なデータ構造を簡単に実装できます。Sealedクラスが階層構造や型の制限を提供するのに対し、データクラスはデータ保持や比較演算を効率的に行えるため、非常に相性が良い組み合わせです。

Sealedクラスとデータクラスの役割

  • Sealedクラス：親クラスとして、子クラスの種類を限定し、階層構造を定義する。
  • データクラス：データの保持、equalsやtoStringなどの標準的なメソッドを自動生成する。

この組み合わせにより、複数の状態やイベント、レスポンスを型安全に管理できるようになります。

例: APIレスポンスの状態管理


以下は、APIレスポンスの状態（成功、エラー、ローディング）をSealedクラスとデータクラスで表現する例です。

sealed class ApiResponse {
    data class Success(val data: String) : ApiResponse()
    data class Error(val errorMessage: String) : ApiResponse()
    object Loading : ApiResponse()
}

fun handleApiResponse(response: ApiResponse) {
    when (response) {
        is ApiResponse.Success -> println("Data: ${response.data}")
        is ApiResponse.Error -> println("Error: ${response.errorMessage}")
        ApiResponse.Loading -> println("Loading...")
    }
}

fun main() {
    val successResponse = ApiResponse.Success("User data fetched successfully")
    val errorResponse = ApiResponse.Error("Failed to fetch user data")
    val loading = ApiResponse.Loading

    handleApiResponse(successResponse)
    handleApiResponse(errorResponse)
    handleApiResponse(loading)
}

コードの解説

  1. sealed class ApiResponse
  • 親クラスとしてAPIレスポンスの状態を定義しています。
  • SuccessやErrorはデータクラス、Loadingはシングルトンオブジェクトです。
  1. data class Successとdata class Error
  • Successはデータを保持し、Errorはエラーメッセージを保持します。
  • データクラスにより、equalsやhashCode、toStringが自動生成されます。
  1. when式による型安全な処理
  • when式を使用することで、Sealedクラスのすべての子クラスが網羅されていることをコンパイラがチェックします。

データクラスの利点

  • 簡潔なデータ保持：データクラスはプロパティをシンプルに管理でき、冗長なボイラープレートコードを排除します。
  • 比較やコピーが容易：copy()関数やequals()メソッドによりデータの比較や複製が簡単になります。
  • 可読性の向上：データクラスを使用することで、クラスの目的が明確になります。

Sealedクラスとデータクラスの組み合わせ例: 状態管理


アプリケーションの状態管理でもこの組み合わせは有効です。例えば、UI状態（ロード中・成功・エラー）を管理する場合：

sealed class UiState {
    object Loading : UiState()
    data class Success(val content: String) : UiState()
    data class Error(val error: String) : UiState()
}

fun displayUiState(state: UiState) {
    when (state) {
        is UiState.Loading -> println("UI is loading...")
        is UiState.Success -> println("Content: ${state.content}")
        is UiState.Error -> println("Error: ${state.error}")
    }
}

まとめ


Sealedクラスとデータクラスを組み合わせることで、階層構造の定義とデータ管理が効率化され、型安全性が高まります。APIレスポンスや状態管理、イベントハンドリングなど、さまざまなシナリオで活用できるため、柔軟かつ簡潔なコード設計が可能です。

Sealedクラスの応用例：状態管理


KotlinのSealedクラスは、複数の状態を安全かつ明確に管理するのに適しています。特にアプリケーション開発において、UIの状態やデータフローを整理するための状態管理に活用されることが多いです。

状態管理とは


アプリケーションは常に異なる状態を持っています。例えば、データの取得中や表示完了、エラーが発生した場合などです。Sealedクラスを使うことで、状態を明確に定義し、コードの可読性と安全性を向上させることができます。

Sealedクラスを使った状態管理の実装例


以下の例では、UIの状態を「読み込み中」「成功」「エラー」に分けて管理しています。

sealed class UiState {
    object Loading : UiState() // 読み込み中
    data class Success(val data: String) : UiState() // 成功状態
    data class Error(val message: String) : UiState() // エラー状態
}

fun displayState(state: UiState) {
    when (state) {
        is UiState.Loading -> println("Loading... Please wait.")
        is UiState.Success -> println("Success: ${state.data}")
        is UiState.Error -> println("Error: ${state.message}")
    }
}

fun main() {
    val loading = UiState.Loading
    val success = UiState.Success("Data loaded successfully!")
    val error = UiState.Error("Failed to load data.")

    displayState(loading)
    displayState(success)
    displayState(error)
}

コードの解説

  1. Sealedクラス UiState
  • UIの状態を3つに分類：Loading（読み込み中）、Success（成功）、Error（エラー）。
  • Loadingはobjectとして定義し、シングルトンで状態を表現しています。
  • SuccessとErrorはdata classを使用し、データやメッセージを保持します。
  1. when式による状態の処理
  • when式で状態ごとに異なる処理を記述しています。
  • Sealedクラスを使用しているため、すべての状態が網羅されていないとコンパイルエラーになります。
  1. 状態ごとの表示
  • 状態に応じたメッセージを表示することで、明確にUIの状態が管理されていることがわかります。

実践的なシナリオ

1. APIレスポンスの管理

データの取得結果（成功、エラー、読み込み中）をシンプルに管理できます。

sealed class ApiState {
    object Loading : ApiState()
    data class Success(val result: String) : ApiState()
    data class Failure(val error: String) : ApiState()
}

2. ViewModelと連携した状態管理

MVVMパターンにおいて、ViewModelからUIの状態をLiveDataやStateFlowを通じて送信し、Sealedクラスで状態を明確に管理します。

class MainViewModel : ViewModel() {
    private val _uiState = MutableLiveData<UiState>()
    val uiState: LiveData<UiState> = _uiState

    fun fetchData() {
        _uiState.value = UiState.Loading
        // データ取得の疑似処理
        try {
            val data = "Fetched data"
            _uiState.value = UiState.Success(data)
        } catch (e: Exception) {
            _uiState.value = UiState.Error("Data fetch failed")
        }
    }
}

Sealedクラスを使うメリット

  • 状態が限定される：意図しない状態が発生しないため、バグの発生を防げる。
  • 型安全性：when式で状態が網羅されているかをコンパイル時にチェックできる。
  • 可読性の向上：状態ごとの処理が明確で、コードの理解が容易になる。

まとめ


Sealedクラスは、状態管理において特に有用です。UIの状態やAPIレスポンスなど、複数の状態を型安全に表現できるため、コードの品質と可読性が向上します。when式との組み合わせにより、すべての状態を網羅した安全な処理が可能になります。

階層構造を効率的に表現する実装例


KotlinのSealedクラスを使うことで、複雑な階層構造を明確かつ効率的に設計できます。Sealedクラスの特徴を活かせば、特定のデータや状態のグループ化が簡単になり、型安全な処理が可能になります。ここでは、階層構造の具体的な実装例を紹介します。

階層構造をSealedクラスで表現するシンプルな例


以下の例では、動物（Animal）を親クラスとして、さまざまな種類の動物を子クラスとして定義しています。

sealed class Animal {
    data class Dog(val breed: String, val age: Int) : Animal()
    data class Cat(val color: String, val age: Int) : Animal()
    object Unknown : Animal()
}

fun describeAnimal(animal: Animal): String {
    return when (animal) {
        is Animal.Dog -> "This is a ${animal.breed} dog, aged ${animal.age} years."
        is Animal.Cat -> "This is a ${animal.color} cat, aged ${animal.age} years."
        Animal.Unknown -> "This is an unknown animal."
    }
}

fun main() {
    val dog = Animal.Dog("Golden Retriever", 3)
    val cat = Animal.Cat("Black", 2)
    val unknown = Animal.Unknown

    println(describeAnimal(dog))
    println(describeAnimal(cat))
    println(describeAnimal(unknown))
}

コードの解説

  1. Sealedクラス Animal
  • Animalは親クラスとしてSealedクラスに定義され、子クラスにはDog、Cat、Unknownがあります。
  • DogとCatはdata classを使用してデータを保持し、Unknownはobjectを使ったシングルトンとして定義しています。
  1. when式の活用
  • describeAnimal関数では、when式を用いて各子クラスごとの処理を記述しています。
  • Sealedクラスを使っているため、すべての子クラスが網羅されているかコンパイル時にチェックされます。
  1. 階層構造の柔軟性
  • Sealedクラスを用いることで、型安全に階層を拡張・管理することができます。

もう少し複雑な階層構造：図形の例


図形を表現する場合も、Sealedクラスは非常に有効です。

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

fun calculateArea(shape: Shape): Double {
    return when (shape) {
        is Shape.Circle -> Math.PI * shape.radius * shape.radius
        is Shape.Rectangle -> shape.width * shape.height
        is Shape.Triangle -> 0.5 * shape.base * shape.height
    }
}

fun main() {
    val circle = Shape.Circle(5.0)
    val rectangle = Shape.Rectangle(4.0, 6.0)
    val triangle = Shape.Triangle(3.0, 4.0)

    println("Circle Area: ${calculateArea(circle)}")
    println("Rectangle Area: ${calculateArea(rectangle)}")
    println("Triangle Area: ${calculateArea(triangle)}")
}

ポイント

  1. Sealedクラスの親クラス Shape
  • Circle、Rectangle、Triangleの3種類の図形を子クラスとして定義しています。
  1. when式での型チェック
  • 各図形に対する面積の計算ロジックをwhen式で分岐処理しています。
  1. 拡張性と安全性
  • 新しい図形を追加する際は、Shapeの子クラスとして定義するだけで、when式が網羅されているかコンパイラがチェックします。

Sealedクラスを使うメリット

  • 型安全性：コンパイル時にすべてのケースが網羅されているかチェックされるため安全です。
  • 可読性と柔軟性：関連するクラスをまとめて階層構造として整理できます。
  • 拡張が容易：新しい状態やデータ型を追加する際も、コードの変更が最小限です。

まとめ


KotlinのSealedクラスは、階層構造を効率的に表現するのに最適です。動物や図形などの具体例を通じて、Sealedクラスがどのように型安全性と拡張性を提供するのかを示しました。when式と組み合わせることで、柔軟かつ安全なコード設計が実現できます。

パターンマッチングとwhen式


KotlinのSealedクラスは、when式と組み合わせることで型安全なパターンマッチングを実現します。Sealedクラスが持つ「子クラスが限定される」という特性によって、when式を使った条件分岐で網羅性が保証され、コンパイル時に安全性がチェックされます。

パターンマッチングとは


パターンマッチングとは、複数の型や状態をパターンとして条件分岐し、それに応じた処理を実行する方法です。Kotlinでは、when式を用いることで、クラスの状態や型に応じた柔軟な処理が記述できます。

Sealedクラスとwhen式の組み合わせ


Sealedクラスをwhen式で扱う場合、すべての子クラスを網羅しているかがコンパイル時にチェックされます。これにより、意図しない漏れが発生しません。

以下は、Sealedクラスとwhen式を組み合わせた具体的な例です。

sealed class Result {
    data class Success(val data: String) : Result()
    data class Failure(val error: String) : Result()
    object Loading : Result()
}

fun handleResult(result: Result) {
    when (result) {
        is Result.Success -> println("Success: ${result.data}")
        is Result.Failure -> println("Error: ${result.error}")
        Result.Loading -> println("Loading...")
    }
}

fun main() {
    val success = Result.Success("Data loaded successfully")
    val failure = Result.Failure("Failed to load data")
    val loading = Result.Loading

    handleResult(success)
    handleResult(failure)
    handleResult(loading)
}

コードの解説

  1. Sealedクラス Result
  • SuccessとFailureはdata classとして定義され、データを保持します。
  • Loadingはobjectとして定義され、シングルトンで動作します。
  1. when式による型チェック
  • when式では、Resultのすべての子クラスを分岐条件として指定しています。
  • Sealedクラスを使用しているため、すべての子クラスがwhen式で扱われていない場合、コンパイルエラーになります。
  1. パターンごとの処理
  • isキーワードを用いて型を判定し、それぞれの型に応じた処理が記述されています。

パターンマッチングの応用


Sealedクラスとwhen式を使ったパターンマッチングは、UI状態やイベント、APIレスポンスの処理に広く利用されます。

例：UI状態管理

UIの状態をSealedクラスで管理し、when式で適切なUI表示を行います。

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

fun displayUiState(state: UiState) {
    when (state) {
        is UiState.Loading -> println("Loading UI...")
        is UiState.Success -> println("Content: ${state.content}")
        is UiState.Error -> println("Error: ${state.message}")
    }
}

例：数式の処理

Sealedクラスを使って数式を階層的に表現し、パターンマッチングで計算を行います。

sealed class Expression {
    data class Number(val value: Int) : Expression()
    data class Add(val left: Expression, val right: Expression) : Expression()
    data class Subtract(val left: Expression, val right: Expression) : Expression()
}

fun evaluate(expr: Expression): Int = when (expr) {
    is Expression.Number -> expr.value
    is Expression.Add -> evaluate(expr.left) + evaluate(expr.right)
    is Expression.Subtract -> evaluate(expr.left) - evaluate(expr.right)
}

fun main() {
    val expression = Expression.Add(
        Expression.Number(10),
        Expression.Subtract(Expression.Number(5), Expression.Number(3))
    )
    println("Result: ${evaluate(expression)}") // Result: 12
}

Sealedクラスとwhen式のメリット

  • 型安全性：when式ですべての子クラスが網羅されていることをコンパイル時に保証します。
  • 可読性の向上：状態やデータごとに処理を明確に記述でき、コードがシンプルになります。
  • 拡張性：新しい状態や子クラスを追加する場合でも、when式の網羅性チェックが行われるため安心です。

まとめ


KotlinのSealedクラスとwhen式を組み合わせることで、型安全なパターンマッチングを実現できます。すべての子クラスを網羅した分岐処理がコンパイル時に保証されるため、バグの発生を防ぎつつ可読性の高いコードを実装できます。状態管理や数式の処理など、さまざまなシナリオでその効果を発揮します。

Sealedクラスの注意点とベストプラクティス


KotlinのSealedクラスは、階層構造や状態管理を型安全に表現できる強力なツールですが、使用する際にはいくつかの注意点と効率的な利用方法（ベストプラクティス）を理解する必要があります。ここでは、Sealedクラスの運用時に知っておくべきポイントを解説します。

Sealedクラスの注意点

1. 子クラスは同じファイル内で定義する必要がある


Sealedクラスの子クラスは、必ず同じファイル内に定義する必要があります。これにより、意図しない子クラスの追加や拡張を防ぐことができます。

sealed class Animal {
    data class Dog(val breed: String) : Animal()
    data class Cat(val color: String) : Animal()
}
// 別ファイルでは子クラスを定義できません

注意：このルールにより、Sealedクラスは大規模なシステムではファイルが肥大化しやすいという欠点があります。

2. Sealedクラスはインスタンス化できない


Sealedクラス自体は抽象クラスの一種であり、直接インスタンス化することはできません。子クラスをインスタンス化して利用することが前提です。

sealed class Result
// val result = Result() // エラー: インスタンス化できない

3. Sealedクラスは継承の柔軟性に欠ける


Sealedクラスは子クラスを同じファイル内に限定するため、拡張性が制限される場合があります。クラス階層を柔軟に拡張したい場合は、通常のabstractクラスを使う方が適しています。

4. パフォーマンスの観点


Sealedクラスはコンパイル時に安全性が保証されますが、子クラスが多すぎる場合や、複雑なロジックが伴う場合には、when式の処理が重くなることがあります。

Sealedクラスのベストプラクティス

1. 状態管理に利用する


Sealedクラスは状態管理の表現に適しており、UIやデータフローの状態を明確に定義できます。状態が固定されている場合は積極的に利用しましょう。

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

2. `when`式との組み合わせ


Sealedクラスはwhen式と併用することで、型安全な条件分岐が可能です。処理の網羅性が保証されるため、漏れのないコードを書けます。

fun handleState(state: UiState) {
    when (state) {
        is UiState.Loading -> println("Loading...")
        is UiState.Success -> println("Data: ${state.data}")
        is UiState.Error -> println("Error: ${state.message}")
    }
}

3. 子クラスの種類は最小限にする


子クラスが多すぎるとコードの可読性が低下し、when式での処理も冗長になります。シンプルで明確な設計を心がけましょう。

4. データクラスやオブジェクトと組み合わせる


Sealedクラスの子クラスは、状況に応じてデータクラスやオブジェクトを使い分けると便利です。

  • データクラス：データを保持する場合。
  • オブジェクト：シングルトンとして動作する場合。
sealed class Response {
    data class Success(val data: String) : Response()
    data class Error(val error: String) : Response()
    object Loading : Response()
}

5. Kotlin 1.5以降：Sealedインターフェースの活用


Kotlin 1.5以降では、Sealedインターフェースも利用可能です。Sealedクラスと異なり、インターフェースを継承する子クラスを複数ファイルに分けて定義することができます。

sealed interface Event
data class Click(val x: Int, val y: Int) : Event
data class KeyPress(val key: String) : Event

まとめ


Sealedクラスは型安全性と網羅性を保証する強力なツールですが、設計時の制約やパフォーマンス面に注意が必要です。状態管理や分岐処理で最大の効果を発揮するため、データクラスやwhen式と組み合わせて効率的に活用しましょう。さらに、子クラスの数は最小限に抑え、可読性と保守性を意識した設計を心がけることが重要です。

まとめ


本記事では、KotlinのSealedクラスを使った階層構造の設計方法について解説しました。Sealedクラスは、関連する状態やデータを型安全に表現し、when式と組み合わせることで網羅性が保証されるため、バグの発生を防ぎながらコードをシンプルかつ明確に保つことができます。

さらに、データクラスやオブジェクトと組み合わせた実装例や、状態管理、パターンマッチングの具体的なシナリオも紹介しました。Sealedクラスの注意点やベストプラクティスを理解することで、効果的な階層構造の設計が可能になります。

KotlinのSealedクラスを活用し、型安全で拡張性の高いコード設計を実践していきましょう。

Kotlin
階層設計 Kotlin sealedクラス

コメント

コメントする

目次