MENU
  1. ホーム
  2. Kotlin
  3. Kotlinの拡張関数を使ったコードのリファクタリング手法と実例

Kotlinの拡張関数を使ったコードのリファクタリング手法と実例

Kotlin

Kotlinの拡張関数を使ったコードリファクタリングは、可読性や保守性を向上させる強力な手法です。拡張関数は既存のクラスに新たな関数を追加する機能で、継承やクラスの修正を行わずに新たな振る舞いを追加できます。本記事では、Kotlinの拡張関数を使った効率的なリファクタリングの方法や具体的な実装例を紹介し、リファクタリングによってコードを簡潔にし、より理解しやすくする方法を解説します。

目次
  1. Kotlinの拡張関数とは何か
    1. 拡張関数の基本構文
    2. 拡張関数の仕組み
    3. 拡張関数の特徴
  2. 拡張関数を使うメリット
    1. 1. コードの可読性向上
    2. 2. クラスの修正が不要
    3. 3. 再利用性の向上
    4. 4. 保守性の向上
    5. 5. シンプルで簡潔なコード
  3. シンプルな拡張関数の実装例
    1. 1. 文字列の最初の文字を大文字にする
    2. 2. リスト内の要素をシャッフルする
    3. 3. 数値の絶対値を取得する
    4. 4. リストの合計値を求める
    5. 5. 日付フォーマットの変換
    6. まとめ
  4. 既存コードのリファクタリング事例
    1. 1. **リスト内の文字列を大文字に変換する**
    2. 2. **文字列が数値かどうかを判定する**
    3. 3. **日付のフォーマット変換**
    4. 4. **リスト内の数値を合計する**
    5. まとめ
  5. 拡張関数でリファクタリングする際の注意点
    1. 1. **拡張関数は静的ディスパッチである**
    2. 2. **拡張関数とメンバ関数の競合**
    3. 3. **拡張関数はプライベートメンバにアクセスできない**
    4. 4. **過度な拡張関数の追加は避ける**
    5. 5. **パッケージや名前空間の整理**
    6. まとめ
  6. 拡張関数とユーティリティ関数の比較
    1. 拡張関数の特徴
    2. ユーティリティ関数の特徴
    3. 使い分けのポイント
    4. 実践例：拡張関数とユーティリティ関数の比較
    5. まとめ
  7. 実際のプロジェクトでの応用例
    1. 1. **APIレスポンスの処理**
    2. 2. **RecyclerViewのアイテムクリック処理**
    3. 3. **Dateのフォーマット変換**
    4. 4. **非同期処理の簡略化**
    5. 5. **文字列のバリデーション**
    6. まとめ
  8. 演習問題：リファクタリングに挑戦
    1. 問題 1: 文字列のバリデーション
    2. 問題 2: リストの合計値を求める
    3. 問題 3: 文字列の先頭と末尾の空白を削除する
    4. 問題 4: リスト内の数値を2倍にする
    5. 問題 5: 日付のフォーマット変換
    6. 解答例
    7. まとめ
  9. まとめ

Kotlinの拡張関数とは何か


Kotlinの拡張関数とは、クラスを変更せずに新しい関数をそのクラスに追加できる機能です。これにより、既存のクラスや標準ライブラリのクラスに対して、追加の機能を付与することができます。

拡張関数の基本構文


拡張関数の定義は次のように行います：

fun クラス名.関数名(引数): 戻り値型 {
    // 関数の処理
}

例えば、Stringクラスに単語の数を数える関数を追加する場合：

fun String.wordCount(): Int {
    return this.split(" ").size
}

この関数は、任意のStringオブジェクトで呼び出すことができます。

val text = "Kotlin is a powerful language"
println(text.wordCount())  // 出力: 5

拡張関数の仕組み


拡張関数は静的に解決されます。つまり、拡張関数は元のクラスのメンバ関数のように振る舞いますが、実際にはクラス自体に変更は加えられません。

拡張関数の特徴

  • 継承不要：既存クラスを継承することなく新しい関数を追加できます。
  • 可読性向上：自然な形でクラスに関数を追加できるため、コードの可読性が高まります。
  • 柔軟性：標準ライブラリやサードパーティライブラリにも機能を追加できます。

このように、拡張関数はKotlin特有の便利な機能であり、コードのリファクタリングや効率化に大きく役立ちます。

拡張関数を使うメリット


Kotlinの拡張関数は、コードのリファクタリングや保守を効率的にするための重要な機能です。ここでは、拡張関数を利用することで得られる主なメリットを解説します。

1. コードの可読性向上


拡張関数を使うことで、クラスに対する操作を自然なメソッド呼び出しの形で記述できます。これにより、コードが直感的になり、読みやすくなります。

例：

fun String.addPrefix(): String = "Prefix: $this"

val message = "Hello"
println(message.addPrefix())  // 出力: Prefix: Hello

2. クラスの修正が不要


クラス本体を編集せずに機能を追加できるため、変更が許されない外部ライブラリや標準ライブラリにも新しい関数を付け加えることが可能です。

3. 再利用性の向上


拡張関数は複数のプロジェクトや異なるクラスで再利用しやすく、共通の機能を簡単に適用できます。

4. 保守性の向上


共通処理を拡張関数としてまとめることで、変更が必要になった際にも修正箇所が少なく済み、保守性が向上します。

5. シンプルで簡潔なコード


拡張関数により、冗長なコードが減り、シンプルで短い記述が可能になります。

従来の記述：

val numbers = listOf(1, 2, 3)
val result = numbers.map { it * 2 }

拡張関数を使った記述：

fun List<Int>.double(): List<Int> = this.map { it * 2 }

val result = listOf(1, 2, 3).double()

これらのメリットを活用することで、Kotlinのコードを効率的にリファクタリングし、より洗練されたプログラムを書くことができます。

シンプルな拡張関数の実装例


Kotlinの拡張関数は、簡単な機能追加から実践的な処理まで幅広く使えます。ここでは、いくつかのシンプルな実装例を紹介します。

1. 文字列の最初の文字を大文字にする


Stringクラスに最初の文字を大文字にする拡張関数を追加します。

fun String.capitalizeFirst(): String {
    return this.replaceFirstChar { it.uppercase() }
}

// 使用例
val text = "kotlin"
println(text.capitalizeFirst())  // 出力: Kotlin

2. リスト内の要素をシャッフルする


Listクラスに要素をランダムに並べ替える拡張関数を追加します。

fun <T> List<T>.shuffleList(): List<T> {
    return this.shuffled()
}

// 使用例
val numbers = listOf(1, 2, 3, 4, 5)
println(numbers.shuffleList())  // 出力: [3, 1, 5, 2, 4]（結果はランダム）

3. 数値の絶対値を取得する


Intクラスに絶対値を取得するシンプルな拡張関数を追加します。

fun Int.toAbsolute(): Int {
    return if (this < 0) -this else this
}

// 使用例
val number = -42
println(number.toAbsolute())  // 出力: 42

4. リストの合計値を求める


List<Int>に合計値を求める拡張関数を追加します。

fun List<Int>.sumOfElements(): Int {
    return this.sum()
}

// 使用例
val values = listOf(1, 2, 3, 4, 5)
println(values.sumOfElements())  // 出力: 15

5. 日付フォーマットの変換


Dateクラスに日付を指定したフォーマットで文字列に変換する拡張関数を追加します。

import java.text.SimpleDateFormat
import java.util.Date

fun Date.toFormattedString(pattern: String): String {
    val formatter = SimpleDateFormat(pattern)
    return formatter.format(this)
}

// 使用例
val currentDate = Date()
println(currentDate.toFormattedString("yyyy/MM/dd"))  // 出力: 2024/06/15

まとめ


これらのシンプルな拡張関数は、日常的な処理を簡単に記述し、コードを分かりやすくするのに役立ちます。これをベースに、さらに高度なリファクタリングに挑戦しましょう。

既存コードのリファクタリング事例


Kotlinの拡張関数を利用すると、冗長なコードや繰り返し処理を簡潔にリファクタリングできます。ここでは、具体的なリファクタリング事例を通して、拡張関数の効果を確認します。

1. **リスト内の文字列を大文字に変換する**

リファクタリング前のコード：

val names = listOf("john", "paul", "george", "ringo")
val upperNames = mutableListOf<String>()
for (name in names) {
    upperNames.add(name.uppercase())
}
println(upperNames)  // 出力: [JOHN, PAUL, GEORGE, RINGO]

リファクタリング後のコード（拡張関数を使用）：

fun List<String>.toUpperCaseList(): List<String> {
    return this.map { it.uppercase() }
}

val names = listOf("john", "paul", "george", "ringo")
println(names.toUpperCaseList())  // 出力: [JOHN, PAUL, GEORGE, RINGO]

2. **文字列が数値かどうかを判定する**

リファクタリング前のコード：

fun isNumeric(str: String): Boolean {
    return str.toIntOrNull() != null
}

val input = "1234"
println(isNumeric(input))  // 出力: true

リファクタリング後のコード（拡張関数を使用）：

fun String.isNumeric(): Boolean {
    return this.toIntOrNull() != null
}

val input = "1234"
println(input.isNumeric())  // 出力: true

3. **日付のフォーマット変換**

リファクタリング前のコード：

import java.text.SimpleDateFormat
import java.util.Date

fun formatDate(date: Date, pattern: String): String {
    val formatter = SimpleDateFormat(pattern)
    return formatter.format(date)
}

val currentDate = Date()
println(formatDate(currentDate, "yyyy-MM-dd"))  // 出力: 2024-06-15

リファクタリング後のコード（拡張関数を使用）：

import java.text.SimpleDateFormat
import java.util.Date

fun Date.toFormattedString(pattern: String): String {
    return SimpleDateFormat(pattern).format(this)
}

val currentDate = Date()
println(currentDate.toFormattedString("yyyy-MM-dd"))  // 出力: 2024-06-15

4. **リスト内の数値を合計する**

リファクタリング前のコード：

val numbers = listOf(1, 2, 3, 4, 5)
var sum = 0
for (number in numbers) {
    sum += number
}
println(sum)  // 出力: 15

リファクタリング後のコード（拡張関数を使用）：

fun List<Int>.sumOfElements(): Int {
    return this.sum()
}

val numbers = listOf(1, 2, 3, 4, 5)
println(numbers.sumOfElements())  // 出力: 15

まとめ


これらのリファクタリング事例から分かるように、Kotlinの拡張関数を使うと、冗長な処理をシンプルで分かりやすい形に変換できます。これにより、コードの可読性と保守性が向上し、日常的なタスクが効率化されます。

拡張関数でリファクタリングする際の注意点


Kotlinの拡張関数は便利ですが、使い方を誤るとコードの保守性や予測可能性に悪影響を及ぼす可能性があります。ここでは、拡張関数を使用する際に気をつけるべきポイントを解説します。

1. **拡張関数は静的ディスパッチである**


拡張関数は、呼び出し時にオブジェクトの実際の型ではなく、宣言された型に基づいて呼び出されます。

例：

open class Animal  
class Dog : Animal()  

fun Animal.speak() = println("Animal is speaking")  
fun Dog.speak() = println("Dog is barking")  

val animal: Animal = Dog()  
animal.speak()  // 出力: Animal is speaking
  • 注意点：拡張関数はオーバーライドされません。ポリモーフィズムの振る舞いを期待する場合、クラス内のメンバ関数として定義する方が適切です。

2. **拡張関数とメンバ関数の競合**


クラスに同名のメンバ関数が存在する場合、メンバ関数が優先されます。

例：

class Sample {
    fun greet() = println("Hello from class")
}

fun Sample.greet() = println("Hello from extension")

val sample = Sample()
sample.greet()  // 出力: Hello from class
  • 注意点：拡張関数が呼ばれず、メンバ関数が優先されるため、名前の競合に注意しましょう。

3. **拡張関数はプライベートメンバにアクセスできない**


拡張関数はクラスのプライベートメンバやプロパティにはアクセスできません。

例：

class Person(private val name: String)

fun Person.getName(): String {
    // return this.name  // エラー: プライベートメンバにはアクセスできない
    return "Access Denied"
}
  • 注意点：拡張関数ではクラスの内部状態に依存した処理ができないため、無理に内部状態にアクセスしようとしないことが重要です。

4. **過度な拡張関数の追加は避ける**


拡張関数を過剰に追加すると、クラスの責務が曖昧になり、コードが散らかりやすくなります。

  • 対策：
  • 汎用的で再利用性の高い関数に限定する。
  • 必要以上にクラスの責務を拡張しない。

5. **パッケージや名前空間の整理**


複数の拡張関数が異なる場所に定義されると、コードの追跡が難しくなります。

  • 対策：
  • 拡張関数は関連するクラスやユーティリティパッケージ内に整理する。
  • 拡張関数を使う際は、インポートや定義場所に注意する。

まとめ


拡張関数は便利ですが、適切に使わないと予期しない挙動やコードの複雑化を招きます。静的ディスパッチやメンバ関数との競合、プライベートメンバへのアクセス制限を理解し、責務が明確でシンプルな拡張関数を心がけることで、効果的なリファクタリングが可能になります。

拡張関数とユーティリティ関数の比較


Kotlinのリファクタリングでは、拡張関数とユーティリティ関数がよく使われますが、これらの使い分けを理解することで、より効率的なコードが書けます。ここでは、それぞれの特徴と適切な使用シーンを比較します。

拡張関数の特徴


拡張関数は、既存のクラスに新しい関数を追加するように見えるKotlinの機能です。クラス本体を変更せずに、直感的に関数を呼び出せるのが利点です。

拡張関数の例：

fun String.isPalindrome(): Boolean {
    return this == this.reversed()
}

val text = "radar"
println(text.isPalindrome())  // 出力: true

メリット：

  • 可読性が高い：オブジェクトに直接メソッドを呼び出す形式で書ける。
  • 自然な記述：既存のクラスに新しい振る舞いを追加する感覚で使える。
  • チェーン呼び出し：メソッドチェーンの一部として利用しやすい。

デメリット：

  • 静的ディスパッチ：クラスの型に基づいて決定されるため、動的なオーバーライドはできない。
  • 競合のリスク：クラスに同名のメンバ関数が存在すると競合する。

ユーティリティ関数の特徴


ユーティリティ関数は、クラスに依存しない形で特定の処理を行う関数です。一般的にはオブジェクトを引数として渡し、処理を行います。

ユーティリティ関数の例：

fun isPalindrome(text: String): Boolean {
    return text == text.reversed()
}

val text = "radar"
println(isPalindrome(text))  // 出力: true

メリット：

  • 独立性：特定のクラスに依存しないため、どこからでも呼び出せる。
  • シンプル：基本的な処理や複数の型で共通する処理に適している。
  • 競合しない：メンバ関数との競合が発生しない。

デメリット：

  • 可読性の低下：オブジェクトに対する操作が関数呼び出しになるため、直感的でない場合がある。
  • チェーン化しづらい：メソッドチェーンのように連続して呼び出すことが難しい。

使い分けのポイント

条件適した手法
直感的にオブジェクトを操作したい拡張関数
特定クラスに新しい振る舞いを追加拡張関数
複数の型に適用する汎用処理ユーティリティ関数
競合や静的ディスパッチを避けたいユーティリティ関数

実践例：拡張関数とユーティリティ関数の比較

拡張関数を使った例：

fun List<Int>.averageValue(): Double {
    return this.average()
}

val numbers = listOf(1, 2, 3, 4, 5)
println(numbers.averageValue())  // 出力: 3.0

ユーティリティ関数を使った例：

fun averageValue(numbers: List<Int>): Double {
    return numbers.average()
}

val numbers = listOf(1, 2, 3, 4, 5)
println(averageValue(numbers))  // 出力: 3.0

まとめ

  • 拡張関数は、直感的でクラスに密接に関連した処理に適しています。
  • ユーティリティ関数は、クラスに依存しない汎用的な処理に向いています。

シーンに応じた適切な選択で、コードの可読性と保守性を向上させましょう。

実際のプロジェクトでの応用例


Kotlinの拡張関数は、実際のプロジェクトにおいてコードをシンプルにし、再利用性や保守性を高めるために非常に有用です。ここでは、拡張関数を活用したリファクタリングの応用例を紹介します。

1. **APIレスポンスの処理**


APIからのJSONレスポンスをStringとして受け取った後、簡単にパースする拡張関数を作成します。

リファクタリング前のコード：

import org.json.JSONObject

val response = "{ \"name\": \"John\", \"age\": 30 }"
val json = JSONObject(response)
val name = json.getString("name")
val age = json.getInt("age")

println("Name: $name, Age: $age")

リファクタリング後のコード（拡張関数を使用）：

import org.json.JSONObject

fun String.toJsonObject(): JSONObject = JSONObject(this)

val response = "{ \"name\": \"John\", \"age\": 30 }"
val json = response.toJsonObject()
println("Name: ${json.getString("name")}, Age: ${json.getInt("age")}")

2. **RecyclerViewのアイテムクリック処理**


RecyclerViewのアイテムクリック処理をシンプルにするための拡張関数を追加します。

リファクタリング前のコード：

recyclerView.addOnItemTouchListener(object : RecyclerView.OnItemTouchListener {
    // 冗長なタッチ処理コードが続く
})

リファクタリング後のコード（拡張関数を使用）：

fun RecyclerView.onItemClick(action: (position: Int) -> Unit) {
    this.addOnItemTouchListener(
        object : RecyclerView.SimpleOnItemTouchListener() {
            override fun onSingleTapUp(e: MotionEvent): Boolean {
                val child = findChildViewUnder(e.x, e.y)
                child?.let {
                    action(getChildAdapterPosition(it))
                }
                return true
            }
        }
    )
}

// 使用例
recyclerView.onItemClick { position ->
    println("Item clicked at position: $position")
}

3. **Dateのフォーマット変換**


日時のフォーマット処理をシンプルにする拡張関数を追加します。

リファクタリング前のコード：

import java.text.SimpleDateFormat
import java.util.Date

val date = Date()
val formatter = SimpleDateFormat("yyyy/MM/dd")
println(formatter.format(date))

リファクタリング後のコード（拡張関数を使用）：

import java.text.SimpleDateFormat
import java.util.Date

fun Date.formatTo(pattern: String): String = SimpleDateFormat(pattern).format(this)

val date = Date()
println(date.formatTo("yyyy/MM/dd"))  // 出力: 2024/06/15

4. **非同期処理の簡略化**


Kotlin Coroutinesを使って非同期処理の簡略化を行う拡張関数を追加します。

リファクタリング前のコード：

GlobalScope.launch {
    delay(1000)
    println("Task completed")
}

リファクタリング後のコード（拡張関数を使用）：

import kotlinx.coroutines.*

fun CoroutineScope.delayAndExecute(timeMillis: Long, action: () -> Unit) {
    launch {
        delay(timeMillis)
        action()
    }
}

// 使用例
GlobalScope.delayAndExecute(1000) {
    println("Task completed")
}

5. **文字列のバリデーション**


入力フォームのバリデーション処理を簡略化するための拡張関数を作成します。

リファクタリング前のコード：

val email = "example@gmail.com"
val isValid = email.contains("@") && email.contains(".")
println("Email is valid: $isValid")

リファクタリング後のコード（拡張関数を使用）：

fun String.isValidEmail(): Boolean {
    return this.contains("@") && this.contains(".")
}

val email = "example@gmail.com"
println("Email is valid: ${email.isValidEmail()}")

まとめ


これらの実践的な拡張関数の応用例を通じて、コードの冗長さを削減し、シンプルで再利用しやすい形にリファクタリングする方法が理解できたと思います。拡張関数を上手く活用することで、プロジェクト全体の保守性と効率性が向上します。

演習問題：リファクタリングに挑戦


ここでは、Kotlinの拡張関数を使って既存コードをリファクタリングする練習問題をいくつか用意しました。拡張関数を使ってコードを簡潔にし、可読性を高めましょう。

問題 1: 文字列のバリデーション


リファクタリング前のコード：

val email = "user@example.com"
val isValid = email.contains("@") && email.contains(".")
println("Email is valid: $isValid")

課題：
この処理を拡張関数にリファクタリングしてください。

問題 2: リストの合計値を求める


リファクタリング前のコード：

val numbers = listOf(10, 20, 30, 40)
var sum = 0
for (num in numbers) {
    sum += num
}
println("Total sum: $sum")

課題：
この合計値を計算する処理を、リストに対する拡張関数にリファクタリングしてください。

問題 3: 文字列の先頭と末尾の空白を削除する


リファクタリング前のコード：

val input = "   Kotlin is fun!   "
val trimmed = input.trim()
println(trimmed)

課題：
この処理をStringクラスの拡張関数としてリファクタリングしてください。

問題 4: リスト内の数値を2倍にする


リファクタリング前のコード：

val numbers = listOf(1, 2, 3, 4, 5)
val doubled = numbers.map { it * 2 }
println(doubled)

課題：
この処理をリストの拡張関数にリファクタリングしてください。

問題 5: 日付のフォーマット変換


リファクタリング前のコード：

import java.text.SimpleDateFormat
import java.util.Date

val date = Date()
val formatter = SimpleDateFormat("yyyy/MM/dd")
println(formatter.format(date))

課題：
日付を指定したフォーマットに変換する処理を、Dateクラスの拡張関数にリファクタリングしてください。

解答例


問題に取り組んだ後、以下の解答例と自分のコードを比較してみてください。

問題 1 解答：

fun String.isValidEmail(): Boolean {
    return this.contains("@") && this.contains(".")
}

問題 2 解答：

fun List<Int>.sumOfElements(): Int {
    return this.sum()
}

問題 3 解答：

fun String.trimWhitespace(): String {
    return this.trim()
}

問題 4 解答：

fun List<Int>.doubleElements(): List<Int> {
    return this.map { it * 2 }
}

問題 5 解答：

fun Date.formatTo(pattern: String): String {
    return SimpleDateFormat(pattern).format(this)
}

まとめ


これらの演習問題を通して、拡張関数を使ったリファクタリングに慣れることができたでしょう。拡張関数を適切に活用することで、コードの再利用性と可読性が向上します。

まとめ


Kotlinの拡張関数は、コードの可読性や保守性を向上させる強力な手法です。本記事では、拡張関数の基本概念から実際のリファクタリング事例、注意点やユーティリティ関数との比較、さらに演習問題を通して理解を深めました。

拡張関数を使うことで、クラス本体を変更せずに機能を追加し、冗長な処理をシンプルにまとめることができます。適切に活用すれば、日常的なタスクを効率化し、クリーンで直感的なコードを書くことが可能です。

この記事を通じて、拡張関数の活用スキルが向上し、実際のプロジェクトでリファクタリングの効果を実感できることでしょう。

Kotlin
リファクタリング Kotlin 拡張関数

コメント

コメントする

目次
  1. Kotlinの拡張関数とは何か
    1. 拡張関数の基本構文
    2. 拡張関数の仕組み
    3. 拡張関数の特徴
  2. 拡張関数を使うメリット
    1. 1. コードの可読性向上
    2. 2. クラスの修正が不要
    3. 3. 再利用性の向上
    4. 4. 保守性の向上
    5. 5. シンプルで簡潔なコード
  3. シンプルな拡張関数の実装例
    1. 1. 文字列の最初の文字を大文字にする
    2. 2. リスト内の要素をシャッフルする
    3. 3. 数値の絶対値を取得する
    4. 4. リストの合計値を求める
    5. 5. 日付フォーマットの変換
    6. まとめ
  4. 既存コードのリファクタリング事例
    1. 1. **リスト内の文字列を大文字に変換する**
    2. 2. **文字列が数値かどうかを判定する**
    3. 3. **日付のフォーマット変換**
    4. 4. **リスト内の数値を合計する**
    5. まとめ
  5. 拡張関数でリファクタリングする際の注意点
    1. 1. **拡張関数は静的ディスパッチである**
    2. 2. **拡張関数とメンバ関数の競合**
    3. 3. **拡張関数はプライベートメンバにアクセスできない**
    4. 4. **過度な拡張関数の追加は避ける**
    5. 5. **パッケージや名前空間の整理**
    6. まとめ
  6. 拡張関数とユーティリティ関数の比較
    1. 拡張関数の特徴
    2. ユーティリティ関数の特徴
    3. 使い分けのポイント
    4. 実践例：拡張関数とユーティリティ関数の比較
    5. まとめ
  7. 実際のプロジェクトでの応用例
    1. 1. **APIレスポンスの処理**
    2. 2. **RecyclerViewのアイテムクリック処理**
    3. 3. **Dateのフォーマット変換**
    4. 4. **非同期処理の簡略化**
    5. 5. **文字列のバリデーション**
    6. まとめ
  8. 演習問題：リファクタリングに挑戦
    1. 問題 1: 文字列のバリデーション
    2. 問題 2: リストの合計値を求める
    3. 問題 3: 文字列の先頭と末尾の空白を削除する
    4. 問題 4: リスト内の数値を2倍にする
    5. 問題 5: 日付のフォーマット変換
    6. 解答例
    7. まとめ
  9. まとめ