MENU
  1. ホーム
  2. Kotlin
  3. Kotlinでシングルトンクラスを作成する方法「objectキーワード」を使った実践ガイド

Kotlinでシングルトンクラスを作成する方法「objectキーワード」を使った実践ガイド

Kotlin
目次
  1. 導入文章
  2. シングルトンパターンとは
    1. シングルトンパターンの目的
    2. シングルトンパターンの利点
  3. Kotlinにおけるシングルトン実装
    1. objectキーワードによるシングルトンの実装
    2. シングルトンのアクセス方法
  4. `object`キーワードの基本構文
    1. 基本構文
    2. 構文の解説
    3. シングルトンの特徴
  5. `object`と`class`の違い
    1. 1. インスタンス化の違い
    2. 2. メモリの管理
    3. 3. ユースケースの違い
    4. まとめ
  6. `object`によるスレッドセーフなシングルトン
    1. スレッドセーフとは
    2. Kotlinの`object`がスレッドセーフな理由
    3. 実際のコード例
    4. スレッドセーフなシングルトン使用時の注意点
    5. まとめ
  7. シングルトンの遅延初期化（Lazy Initialization）
    1. 遅延初期化の利点
    2. 遅延初期化の動作例
    3. 遅延初期化の仕組み
    4. まとめ
  8. シングルトンにおけるプロパティとメソッドの定義
    1. プロパティの定義
    2. プロパティの使用例
    3. メソッドの定義と使用
    4. プロパティとメソッドの組み合わせ
    5. まとめ
  9. シングルトンの応用例: 設定管理クラスとしての利用
    1. 設定管理クラスの実装例
    2. 設定の使用例
    3. シングルトンの利点
    4. シングルトンを使った設定管理の他のユースケース
    5. まとめ
  10. まとめ
  11. シングルトンパターンの課題と注意点
    1. 1. グローバル状態の管理
    2. 2. モックやスタブの作成が難しい
    3. 3. シングルトンの初期化時のコスト
    4. 4. 無限依存関係
    5. まとめ

導入文章


Kotlinでは、シングルトンパターンを簡単に実装できる方法としてobjectキーワードが提供されています。このキーワードを使用することで、クラスのインスタンスをアプリケーション全体で一度だけ生成し、どこからでもアクセスできるようにすることができます。本記事では、Kotlinでシングルトンクラスを作成する方法と、その活用例を詳しく解説します。シングルトンパターンを理解し、効率的なコードを書くための手法を学びましょう。

シングルトンパターンとは


シングルトンパターンは、クラスのインスタンスがアプリケーション全体で一度だけ生成され、常にそのインスタンスを使用するデザインパターンです。このパターンは、特定のリソース（例えば設定情報やデータベース接続）を複数回インスタンス化せず、ひとつのインスタンスで管理する必要がある場面で活用されます。

シングルトンパターンの目的


シングルトンパターンの主な目的は、リソースの無駄な消費を防ぎ、状態の一貫性を保つことです。例えば、設定ファイルを読み込むクラスや、アプリケーションのロギングを担当するクラスにシングルトンを使用することで、リソースの再利用が促進されます。

シングルトンパターンの利点

  • インスタンスの一貫性: プログラム全体で常に同じインスタンスが使用されるため、状態が一貫します。
  • リソースの節約: 必要な時に一度だけインスタンス化されるため、無駄なオブジェクトの生成を避けられます。
  • グローバルアクセス: どこからでもインスタンスにアクセスできるため、複雑な依存関係を避けることができます。

シングルトンパターンは、単一のリソースを管理する必要があるシナリオで非常に効果的です。しかし、過度に使用するとテストやデバッグが難しくなる可能性があるため、適切な場面での利用が重要です。

Kotlinにおけるシングルトン実装


Kotlinでは、シングルトンパターンを非常に簡単に実装できます。これを実現するために、objectキーワードを使用します。objectキーワードを使うと、そのクラスのインスタンスは一度だけ生成され、アプリケーション全体でそのインスタンスを共有することができます。

objectキーワードによるシングルトンの実装


Kotlinでは、objectキーワードを使うことで、シングルトンインスタンスを自動的に作成できます。次のコードは、その基本的な構文を示しています。

object Singleton {
    val property = "This is a singleton"
    fun method() {
        println("Method in Singleton")
    }
}

このコードでは、Singletonという名前のオブジェクト（シングルトンクラス）を定義しています。Singletonオブジェクトは、最初にアクセスされたときに初期化され、以後どこからでも同じインスタンスを使用できます。

シングルトンのアクセス方法


objectで定義されたシングルトンは、インスタンス化せずに直接アクセスできます。例えば、次のようにシングルトンのプロパティやメソッドを呼び出せます。

fun main() {
    println(Singleton.property) // "This is a singleton"
    Singleton.method() // "Method in Singleton"
}

ここで重要なのは、Singletonのインスタンスを新たに生成することなく、クラス名を通じて直接アクセスできる点です。これにより、コードがシンプルになり、インスタンス管理の手間が省けます。

`object`キーワードの基本構文


Kotlinにおけるシングルトンを実装するためには、objectキーワードを使用します。このキーワードを使うことで、インスタンスが一度だけ生成され、同じインスタンスがアプリケーション全体で共有されます。以下に、objectを用いたシングルトンの基本的な構文を示します。

基本構文

object Singleton {
    val property = "This is a singleton"

    fun method() {
        println("Method in Singleton")
    }
}

このコードは非常にシンプルで、objectキーワードで定義されたSingletonは、自動的にシングルトンとして機能します。クラス名Singletonはインスタンスの生成も行わず、そのまま直接アクセスできます。

構文の解説

  • object Singleton: これは、シングルトンインスタンスを定義する部分です。Singletonという名前のインスタンスがアプリケーション全体で一度だけ作成されます。
  • val property: Singletonオブジェクトに含まれるプロパティです。このプロパティはどこからでもアクセス可能です。
  • fun method(): Singletonオブジェクトのメソッドです。メソッドも、シングルトンインスタンスを通じてアクセスできます。

シングルトンの特徴

  • 一度だけインスタンス化: objectで定義されたクラスは最初にアクセスされたときに初期化され、その後は再初期化されることはありません。
  • シングルトンのアクセス: objectによって生成されたインスタンスは、インスタンス化せずにそのままアクセス可能です。

このように、Kotlinのobjectを使うことで、シングルトンパターンを簡潔に実装することができ、複雑なコードを避けることができます。

`object`と`class`の違い


Kotlinでは、objectとclassのどちらもクラスを定義するために使いますが、目的と動作において大きな違いがあります。objectは主にシングルトンパターンを実装するために使用され、一度だけインスタンス化されるクラスを作成します。一方、classは通常のクラス定義に使われ、インスタンスは手動で作成する必要があります。ここでは、objectとclassの違いについて詳しく説明します。

1. インスタンス化の違い

  • object
    objectで定義されたクラスは、アプリケーション全体で一度だけインスタンス化されます。このインスタンスは自動的に生成され、どこからでもアクセスできます。インスタンス化を手動で行う必要はありません。
  object Singleton {
      val property = "This is a singleton"
  }

  // 使用例
  println(Singleton.property) // インスタンス化せずにアクセス
  • class
    classで定義されたクラスは、通常のクラスであり、インスタンス化は手動で行う必要があります。classを使うと、複数のインスタンスを作成することができます。
  class MyClass(val name: String)

  // 使用例
  val myClassInstance = MyClass("Example")
  println(myClassInstance.name) // インスタンス化してアクセス

2. メモリの管理

  • object
    objectで定義されたクラスは、最初にアクセスされたときに一度だけインスタンスが生成され、以後は同じインスタンスが再利用されます。これにより、メモリ使用が効率的に管理されます。
  • class
    classで定義されたクラスは、インスタンスを明示的に生成するため、必要な数だけインスタンスを作成できます。つまり、同じクラスから複数のインスタンスを作ることができます。

3. ユースケースの違い

  • object
    シングルトンパターンに最適です。例えば、アプリケーション全体で共通の設定やリソースを管理するためのクラスに使用されます。また、クラスにアクセスする際のシンプルさも魅力です。
  • class
    複数の異なるオブジェクトを生成する必要がある場合や、異なる状態を持つインスタンスを複数管理したい場合に使用されます。通常のオブジェクト指向プログラミングのクラスとして広く使われています。

まとめ


objectとclassは、インスタンスの管理方法に違いがあります。objectはシングルトンとして使われ、一度だけインスタンスが生成され、アプリケーション全体で共有されます。一方、classは通常のクラスとして、手動でインスタンス化されるため、複数のインスタンスを作成できます。シングルトンパターンを利用する場合は、objectが適しており、複数のインスタンスが必要な場合にはclassが適しています。

`object`によるスレッドセーフなシングルトン


Kotlinのobjectキーワードで定義されたシングルトンは、デフォルトでスレッドセーフです。これは、複数のスレッドから同時にアクセスされても、インスタンスが一度だけ生成されることが保証されていることを意味します。スレッドセーフであるため、並列処理が行われる環境でも、複数のスレッドが同じインスタンスにアクセスしても問題が発生しません。

スレッドセーフとは


スレッドセーフとは、複数のスレッドが同時に実行されている環境でも、プログラムが予期しない動作をしないことを指します。特に、データの競合状態や状態の不一致が発生しないようにするための設計が求められます。

Kotlinの`object`がスレッドセーフな理由


Kotlinのobjectキーワードで定義されたインスタンスは、JVMの初期化の際に、「最初にアクセスされたときに初期化される」という特徴を持っています。この初期化は遅延初期化（Lazy Initialization）として行われ、Kotlinのランタイムが初期化を安全に行うため、スレッドセーフです。具体的には、objectのインスタンスは、JVMがロードする段階でロックを使用して適切に初期化されるため、複数のスレッドから同時にアクセスされても問題が生じません。

実際のコード例


以下は、Kotlinで定義されたスレッドセーフなシングルトンの簡単な例です。

object ThreadSafeSingleton {
    var count = 0

    fun increment() {
        count++
    }
}

上記のコードでは、ThreadSafeSingletonというシングルトンがobjectとして定義されています。count変数に対するインクリメント操作も問題なく動作します。このobjectは、複数のスレッドから同時にアクセスしても、インスタンスは一度しか作成されないため、競合状態が発生しません。

スレッドセーフなシングルトン使用時の注意点

  • スレッドセーフであることの保証: Kotlinのobjectは初期化時にスレッドセーフですが、シングルトン内部で状態を変更するような場合（例えば、グローバル変数を更新する場合）には、その変更が競合状態を引き起こさないように、追加の同期処理が必要なことがあります。
  • 並列処理との併用: スレッドセーフとはいえ、もしobject内で複雑な状態の変更や並列処理を行う場合には、ロック機構やスレッド間の調整が求められることもあります。特に、複数スレッドが同じリソースを更新する場合には注意が必要です。

まとめ


Kotlinのobjectキーワードによって作成されたシングルトンは、デフォルトでスレッドセーフです。これにより、複数のスレッドから同時にアクセスされても、インスタンスが一度だけ生成されることが保証され、並列処理環境でも安定して動作します。しかし、シングルトン内で状態を変更する場合には、追加の同期処理が必要な場合もあるため、使用する際には注意が必要です。

シングルトンの遅延初期化（Lazy Initialization）


Kotlinのobjectで定義されたシングルトンは、遅延初期化をサポートしています。遅延初期化とは、シングルトンのインスタンスが最初にアクセスされたときに初めて作成されるという仕組みです。これにより、インスタンスが不要な場合は、初期化を遅らせることができ、効率的なメモリ使用が可能になります。

遅延初期化の利点

  • 無駄な初期化の回避: インスタンスが実際に使用されるまで初期化を遅延させることができ、不要なオブジェクト生成を防ぎます。
  • 初期化コストの削減: アプリケーションの起動時にすぐにインスタンスを生成しないため、初期化コストが高い場合にパフォーマンスが向上します。
  • リソースの節約: シングルトンが使われない限りインスタンスが生成されないため、メモリやCPUリソースを無駄に消費しません。

遅延初期化の動作例


Kotlinのobjectは、遅延初期化が標準で有効になっています。最初にアクセスされたときに、インスタンスが初めて生成され、以後は同じインスタンスが使用され続けます。以下のコードは、遅延初期化を利用したシングルトンの例です。

object Singleton {
    val property = "This is a singleton"

    init {
        println("Singleton instance initialized")
    }
}

fun main() {
    println("Before accessing Singleton")
    println(Singleton.property)  // 初めてアクセスするときに初期化される
    println("After accessing Singleton")
}

この例では、Singletonオブジェクトが最初にアクセスされたときに「Singleton instance initialized」と表示されます。それまではインスタンスが生成されることはありません。

遅延初期化の仕組み


Kotlinのobjectは、最初にアクセスされるまでインスタンスの初期化を遅らせます。初期化はスレッドセーフであり、最初にアクセスされるスレッドがインスタンスを作成し、その後はそのインスタンスが再利用されます。これにより、不要なオブジェクトの生成を避け、アプリケーションのパフォーマンスを最適化します。

まとめ


Kotlinのobjectを使ったシングルトンは、遅延初期化を標準でサポートしており、最初にインスタンスが必要とされるまで生成を遅らせることができます。この仕組みによって、リソースの無駄を防ぎ、パフォーマンスを向上させることが可能です。

シングルトンにおけるプロパティとメソッドの定義


Kotlinのobjectによって作成されたシングルトンは、クラスと同様にプロパティやメソッドを定義できます。シングルトン内のプロパティやメソッドは、そのインスタンスを通じてアクセスされ、アプリケーション全体で一貫した状態を保ちます。ここでは、シングルトン内でのプロパティとメソッドの定義方法、そしてそれらの使用方法について解説します。

プロパティの定義


シングルトン内のプロパティは、object内で直接定義することができます。これらのプロパティは、シングルトンインスタンスが生成された後、アクセス可能です。プロパティはval（不変）またはvar（可変）として定義できます。

object Singleton {
    val immutableProperty: String = "I am immutable"
    var mutableProperty: Int = 0

    fun increment() {
        mutableProperty++
    }
}

上記の例では、immutablePropertyという不変のプロパティと、mutablePropertyという可変のプロパティを定義しています。また、increment()メソッドを定義して、mutablePropertyの値を変更できるようにしています。

プロパティの使用例


シングルトン内のプロパティは、インスタンス化せずにクラス名を通じてアクセスできます。以下は、Singletonオブジェクト内のプロパティにアクセスする方法です。

fun main() {
    // 不変プロパティにアクセス
    println(Singleton.immutableProperty) // 出力: I am immutable

    // 可変プロパティにアクセス
    println(Singleton.mutableProperty) // 出力: 0
    Singleton.increment()
    println(Singleton.mutableProperty) // 出力: 1
}

このように、シングルトン内のプロパティはSingleton.propertyNameの形式でアクセスされ、必要に応じて変更できます。

メソッドの定義と使用


シングルトン内には、プロパティだけでなく、関数（メソッド）も定義することができます。これらのメソッドは、シングルトンインスタンスを通じて呼び出されます。以下の例では、method()というメソッドを定義しています。

object Singleton {
    fun method() {
        println("Method in Singleton is called")
    }
}

このmethod()は、シングルトンインスタンスを通じて呼び出すことができます。

fun main() {
    Singleton.method() // 出力: Method in Singleton is called
}

プロパティとメソッドの組み合わせ


シングルトン内でプロパティとメソッドを組み合わせて、より複雑なロジックを構築することができます。例えば、次のコードでは、countというプロパティをカウントアップするメソッドを定義しています。

object Singleton {
    var count = 0

    fun increment() {
        count++
    }

    fun displayCount() {
        println("Count: $count")
    }
}

fun main() {
    Singleton.displayCount() // 出力: Count: 0
    Singleton.increment()
    Singleton.displayCount() // 出力: Count: 1
}

ここでは、countというプロパティを増加させるincrement()メソッドを呼び出し、その後displayCount()メソッドでカウントを表示しています。

まとめ


Kotlinのシングルトン内では、プロパティとメソッドを定義することができ、それらはシングルトンインスタンスを通じてアクセスされます。プロパティはvalやvarを使って定義され、メソッドは通常のクラスのメソッドと同じように定義されます。これにより、シングルトンはシンプルで効率的なコード設計が可能になります。

シングルトンの応用例: 設定管理クラスとしての利用


シングルトンパターンは、アプリケーション全体で共通の状態を管理するために非常に有用です。例えば、アプリケーションの設定情報を一元管理する設定管理クラスにシングルトンを利用することができます。このようなクラスは、どの部分からでもアクセスできるため、アプリケーション内で設定の状態が常に一貫性を保つことができます。

設定管理クラスの実装例


以下は、アプリケーションの設定情報を管理するシングルトンの例です。設定はMapで保持され、getとsetメソッドを通じてアクセスされます。

object AppConfig {
    private val settings = mutableMapOf<String, String>()

    fun set(key: String, value: String) {
        settings[key] = value
    }

    fun get(key: String): String? {
        return settings[key]
    }

    fun displaySettings() {
        settings.forEach { (key, value) ->
            println("$key: $value")
        }
    }
}

このAppConfigオブジェクトは、アプリケーション全体で共通の設定情報を管理します。設定の追加や取得は、setメソッドとgetメソッドを通じて行われます。さらに、displaySettingsメソッドを使って、現在の設定情報を一覧表示できます。

設定の使用例


以下のコードは、設定管理クラスを使用してアプリケーションの設定を設定・取得・表示する例です。

fun main() {
    // 設定を設定
    AppConfig.set("theme", "dark")
    AppConfig.set("language", "en")

    // 設定を取得
    println("Theme: ${AppConfig.get("theme")}")  // 出力: Theme: dark
    println("Language: ${AppConfig.get("language")}")  // 出力: Language: en

    // 設定を表示
    AppConfig.displaySettings()  // 出力: theme: dark, language: en
}

このように、AppConfigシングルトンを使うことで、どの部分のコードからでも同じ設定情報にアクセスでき、設定が一元管理されるため、コードがシンプルで保守性の高いものになります。

シングルトンの利点

  • 一貫性: 設定情報が一度だけ定義され、アプリケーション全体で一貫した状態を保つことができます。
  • グローバルアクセス: シングルトンはアプリケーション内のどこからでもアクセス可能で、設定の管理を簡素化します。
  • 効率性: インスタンス化が一度きりであるため、メモリ使用が効率的です。

シングルトンを使った設定管理の他のユースケース


シングルトンパターンは設定管理以外にもさまざまな場面で活用できます。例えば、以下のようなユースケースでも有効です：

  • ログ管理: アプリケーション全体で共通のログ出力設定やログレベルを管理するためのシングルトン。
  • データベース接続: データベース接続を一度だけ初期化し、アプリケーション全体で使い回すためのシングルトン。
  • キャッシュ管理: キャッシュデータを一元管理し、複数のコンポーネントで共有するためのシングルトン。

まとめ


シングルトンパターンは、設定管理のように、アプリケーション全体で共有するべきリソースや情報を効率よく管理するために非常に便利です。Kotlinのobjectを使えば、シングルトンの実装が非常に簡潔でスレッドセーフであるため、設定情報などの一貫性を保つ必要がある場面で活用できます。

まとめ


本記事では、Kotlinにおけるシングルトンクラスの作成方法について、objectキーワードを使用した実装方法から、スレッドセーフ性、遅延初期化、プロパティとメソッドの定義方法、さらには実際のアプリケーションでの活用例まで、広範囲にわたって解説しました。

シングルトンパターンは、アプリケーション全体で共有されるインスタンスを確実に一度だけ作成し、そのインスタンスを管理するための強力な手法です。Kotlinのobjectキーワードを使うことで、簡潔にシングルトンを実装でき、また自動的にスレッドセーフで遅延初期化されるため、並行処理を行うアプリケーションにも適しています。

さらに、シングルトン内でプロパティやメソッドを定義することによって、アプリケーションの設定情報やログ管理など、さまざまなユースケースで効果的に使用することができます。

シングルトンパターンを適切に活用することで、コードの一貫性や効率性が向上し、より簡潔で保守性の高いシステムを構築できます。

シングルトンパターンの課題と注意点


シングルトンパターンは非常に便利ですが、使用する際にはいくつかの課題や注意点もあります。適切に使用しないと、設計の問題やパフォーマンスの低下を招く可能性があります。ここでは、シングルトンパターンを使用する際に考慮すべき課題と注意点について説明します。

1. グローバル状態の管理


シングルトンはアプリケーション全体で単一のインスタンスを共有するため、グローバルな状態を管理することになります。このような状態管理は、他のクラスから容易にアクセスできる一方で、次のような問題を引き起こすことがあります：

  • 依存関係の不明確化: グローバルな状態が多すぎると、どのクラスがその状態に依存しているのかが不明確になり、保守性が低下します。
  • テストの難易度: グローバルな状態が変更されると、他のテストケースにも影響を与える可能性があります。このため、ユニットテストが難しくなります。

対策として、シングルトン内で保持する状態は最小限にとどめ、依存性注入（DI）などの手法を用いてグローバル状態に依存しない設計を心掛けることが推奨されます。

2. モックやスタブの作成が難しい


シングルトンは通常、アプリケーション全体で共有されるため、テスト環境でモックやスタブを作成することが難しくなります。例えば、シングルトンが外部サービスとの接続を管理している場合、その接続をモックしてテストを行いたいときに、シングルトンのインスタンスが自動的に生成されてしまうため、テストが複雑になることがあります。

この課題に対処するためには、インターフェースを利用してシングルトンに依存するクラスを抽象化する方法が考えられます。また、テスト用の設定を加えたり、モック用のフレームワーク（例えば、Mockitoなど）を利用することで、テスト環境を整えることができます。

3. シングルトンの初期化時のコスト


シングルトンが初めてアクセスされた際にインスタンスが生成されるため、その初期化に時間がかかる場合、パフォーマンスに影響を与えることがあります。特に、シングルトン内で重い処理やリソースの初期化を行っている場合、その遅延がアプリケーションのレスポンスに影響を与えることがあります。

遅延初期化（Lazy Initialization）を使用する場合でも、初期化処理が重い場合は、最初にアクセスするまで処理を遅らせることが必須です。初期化処理を軽量化するか、初期化をバックグラウンドで行う方法を検討することが重要です。

4. 無限依存関係


シングルトンのインスタンスが他のシングルトンに依存している場合、無限に依存関係がループしてしまう可能性があります。これは「依存関係の循環」問題として知られており、シングルトンが複雑になればなるほど、どのインスタンスが先に初期化されるべきかがわからなくなり、アプリケーションの動作に不具合が生じることがあります。

この問題を回避するためには、依存関係をできるだけ減らすことが重要です。循環依存が発生しないように、依存関係を平坦化し、できればシングルトン間の依存をなくす設計を心掛けましょう。

まとめ


シングルトンパターンは強力で便利なデザインパターンですが、その使用にはいくつかの注意点と課題があります。グローバル状態の管理や依存関係の不明確化、テストの難易度、初期化コスト、依存関係の循環など、問題が発生する可能性があるため、これらを適切に管理することが重要です。シングルトンを活用する際には、これらの課題に対する対策を講じ、柔軟かつ保守性の高いアーキテクチャを構築することを心掛けましょう。

Kotlin
プログラミング シングルトン Kotlin object

コメント

コメントする

目次
  1. 導入文章
  2. シングルトンパターンとは
    1. シングルトンパターンの目的
    2. シングルトンパターンの利点
  3. Kotlinにおけるシングルトン実装
    1. objectキーワードによるシングルトンの実装
    2. シングルトンのアクセス方法
  4. `object`キーワードの基本構文
    1. 基本構文
    2. 構文の解説
    3. シングルトンの特徴
  5. `object`と`class`の違い
    1. 1. インスタンス化の違い
    2. 2. メモリの管理
    3. 3. ユースケースの違い
    4. まとめ
  6. `object`によるスレッドセーフなシングルトン
    1. スレッドセーフとは
    2. Kotlinの`object`がスレッドセーフな理由
    3. 実際のコード例
    4. スレッドセーフなシングルトン使用時の注意点
    5. まとめ
  7. シングルトンの遅延初期化（Lazy Initialization）
    1. 遅延初期化の利点
    2. 遅延初期化の動作例
    3. 遅延初期化の仕組み
    4. まとめ
  8. シングルトンにおけるプロパティとメソッドの定義
    1. プロパティの定義
    2. プロパティの使用例
    3. メソッドの定義と使用
    4. プロパティとメソッドの組み合わせ
    5. まとめ
  9. シングルトンの応用例: 設定管理クラスとしての利用
    1. 設定管理クラスの実装例
    2. 設定の使用例
    3. シングルトンの利点
    4. シングルトンを使った設定管理の他のユースケース
    5. まとめ
  10. まとめ
  11. シングルトンパターンの課題と注意点
    1. 1. グローバル状態の管理
    2. 2. モックやスタブの作成が難しい
    3. 3. シングルトンの初期化時のコスト
    4. 4. 無限依存関係
    5. まとめ