KotlinのDelegated Propertiesを使ったプロパティ変更検知方法を徹底解説

Kotlinでプロパティの変更を検知する便利な方法としてDelegated Propertiesのobservableが提供されています。アプリケーション開発において、データの変更を即座に追跡し、適切な処理を行うことは非常に重要です。例えば、UIの更新や状態管理において、プロパティが変更された瞬間に動作を反映させることが求められます。

従来、プロパティの変更検知を行うためには、手動でgetter・setterを実装したり、専用のイベント通知を設けたりする必要がありました。しかし、Kotlinではobservableデリゲートを使用することで、これらの作業を大幅に簡素化し、効率的にプロパティの変更を検知することが可能です。

本記事では、KotlinのDelegated Propertiesの仕組みとobservableの使い方を具体的なコード例を交えて解説します。これにより、Kotlinを使用したアプリケーションでプロパティ変更を効果的に扱えるようになります。

Delegated Propertiesとは何か

KotlinのDelegated Properties（委譲プロパティ）とは、プロパティの振る舞いを別のオブジェクト（デリゲート）に委譲する仕組みのことです。これにより、プロパティの定義とその処理のロジックを分離し、再利用性や可読性を高めることができます。

Delegated Propertiesの基本的な仕組み

Delegated Propertiesは、Kotlinのbyキーワードを使って宣言されます。プロパティの値や動作を別のオブジェクトが管理し、その結果をプロパティとして利用する形になります。

基本構文:

class MyClass {
    var property: String by Delegate()
}

ここでDelegate()はプロパティの動作をカスタマイズするデリゲートクラスです。

標準ライブラリで提供されるデリゲート

Kotlinでは、いくつかの便利なデリゲートが標準ライブラリで提供されています。代表的なものには以下のものがあります：

lazy：初回アクセス時に値を計算し、その後キャッシュするデリゲート。
observable：プロパティの変更を検知し、コールバックを実行するデリゲート。
vetoable：プロパティ変更前に条件を評価し、変更を拒否できるデリゲート。

Delegated Propertiesのメリット

コードの簡素化：共通のロジックをデリゲートに委譲することで、コードが簡潔になります。
再利用性：同じデリゲートを複数のプロパティで利用できるため、ロジックを再利用しやすくなります。
柔軟な拡張：独自のデリゲートを作成することで、さまざまな処理を柔軟に実装できます。

次のセクションでは、プロパティ変更を検知するobservableデリゲートの仕組みについて、詳しく解説します。

observableデリゲートの概要

Kotlinのobservableデリゲートは、プロパティの変更を検知し、その変更前後の値を追跡するための機能です。プロパティが変更されるたびに指定したコールバックが実行されるため、プロパティの状態変化に応じて何らかの処理を行いたい場合に非常に有用です。

observableデリゲートの仕組み

observableデリゲートは、Kotlin標準ライブラリのDelegatesオブジェクト内に含まれています。observableを使用する際には、Delegates.observableメソッドを利用します。

基本構文:

import kotlin.properties.Delegates

class Example {
    var property: String by Delegates.observable("初期値") { property, oldValue, newValue ->
        println("$property は $oldValue から $newValue に変更されました")
    }
}

"初期値"：プロパティの初期値です。
コールバック：プロパティが変更されるたびに呼び出される関数です。引数には以下が渡されます：
property：変更されたプロパティ自体
oldValue：変更前の値
newValue：変更後の値

observableの動作例

以下の例でobservableデリゲートの動作を確認します：

import kotlin.properties.Delegates

fun main() {
    var name: String by Delegates.observable("初期名") { prop, old, new ->
        println("プロパティ '${prop.name}' は '$old' から '$new' に変更されました")
    }

    name = "新しい名前" // 変更検知
    name = "さらに新しい名前" // 再度変更検知
}

出力結果：

プロパティ 'name' は '初期名' から '新しい名前' に変更されました  
プロパティ 'name' は '新しい名前' から 'さらに新しい名前' に変更されました

observableの用途

observableデリゲートは、主に以下の用途で利用されます：

UIの更新：プロパティ変更時に画面やコンポーネントを更新する。
デバッグやログ出力：プロパティの変更履歴を追跡する。
状態管理：アプリケーションやシステムの状態の変更を監視する。

次のセクションでは、observableの基本的な使い方を具体的なコード例とともにさらに詳しく解説します。

observableの基本的な使い方

KotlinのDelegates.observableを使用してプロパティの変更を検知する基本的な使い方を、具体的なコード例を用いて説明します。

基本的なコード例

observableを使うことで、プロパティの変更時に任意の処理を実行することができます。

import kotlin.properties.Delegates

class User {
    var name: String by Delegates.observable("初期値") { property, oldValue, newValue ->
        println("プロパティ '${property.name}' が変更されました: '$oldValue' → '$newValue'")
    }
}

fun main() {
    val user = User()
    println("初期値: ${user.name}")

    user.name = "太郎"  // 変更時のコールバックが呼び出される
    user.name = "次郎"  // さらに変更
}

実行結果

初期値: 初期値  
プロパティ 'name' が変更されました: '初期値' → '太郎'  
プロパティ 'name' が変更されました: '太郎' → '次郎'

このコードのポイント：

初期値：Delegates.observableの第1引数でプロパティの初期値を指定します。
コールバック関数：プロパティの変更が発生すると、第2引数に指定したコールバック関数が実行されます。

property：変更されたプロパティ名を取得します。
oldValue：変更前の値を取得します。
newValue：変更後の値を取得します。

複数のobservableプロパティを定義

複数のプロパティに対してobservableを適用することも可能です。

import kotlin.properties.Delegates

class User {
    var name: String by Delegates.observable("名無し") { _, old, new ->
        println("名前が変更されました: $old → $new")
    }

    var age: Int by Delegates.observable(0) { _, old, new ->
        println("年齢が変更されました: $old → $new")
    }
}

fun main() {
    val user = User()

    user.name = "花子"  // 名前の変更を検知
    user.age = 25       // 年齢の変更を検知
}

実行結果

名前が変更されました: 名無し → 花子  
年齢が変更されました: 0 → 25

observableを活用した状態の管理

observableはUIや状態管理システムと組み合わせることで、データの変更を自動的に反映する処理が書けます。

例えば、Androidアプリ開発では以下のように利用できます：

class ViewModel {
    var userName: String by Delegates.observable("未設定") { _, old, new ->
        println("ユーザー名が更新されました: $old → $new")
        // UI更新処理をここで呼び出す
    }
}

このように、observableデリゲートは簡単にプロパティ変更を検知し、柔軟に処理を追加できるため、状態管理やログ出力など様々なシーンで役立ちます。

次のセクションでは、beforeChangeやafterChangeの動作について詳しく解説します。

beforeChangeとafterChangeの動作

KotlinのDelegated Propertiesには、observableに加えて、変更前の動作を制御するbeforeChangeや、変更後に追加処理を行うafterChangeがあります。これらを利用することで、プロパティの変更前後に柔軟な処理を追加することが可能です。

beforeChangeの概要

beforeChangeは、プロパティの変更が発生する前に呼び出されるコールバックです。変更を許可するかどうかをBoolean値で返すことができます。falseを返すと変更はキャンセルされ、プロパティの値は変更されません。

構文:

import kotlin.properties.Delegates

class Example {
    var count: Int by Delegates.vetoable(0) { property, oldValue, newValue ->
        println("変更前: ${property.name}: $oldValue → $newValue")
        newValue >= 0 // 値が0未満なら変更を拒否
    }
}

fun main() {
    val example = Example()
    println("初期値: ${example.count}")

    example.count = 5  // 変更が許可される
    example.count = -1 // 変更が拒否される
}

実行結果

初期値: 0  
変更前: count: 0 → 5  
変更前: count: 5 → -1

ポイント：newValue >= 0で条件を評価し、falseなら値は変更されません。

afterChangeの概要

afterChangeは、observableと同様に、プロパティの値が変更された直後に呼び出されるコールバックです。afterChangeでは変更の履歴を追跡したり、変更後の値に基づいた処理を行うことができます。

構文:

import kotlin.properties.Delegates

class Example {
    var count: Int by Delegates.observable(0) { property, oldValue, newValue ->
        println("変更後: ${property.name}: $oldValue → $newValue")
    }
}

fun main() {
    val example = Example()
    println("初期値: ${example.count}")

    example.count = 10  // 値が変更される
    example.count = 20  // 値が変更される
}

実行結果

初期値: 0  
変更後: count: 0 → 10  
変更後: count: 10 → 20

beforeChangeとafterChangeの使い分け

beforeChange：プロパティの変更を検証し、変更の許可・拒否を判断する。
例：入力値のバリデーション、負の値の拒否など。
afterChange：プロパティの変更後に、履歴の記録やUIの更新などの処理を行う。
例：ログ記録、データバインディングの更新。

beforeChangeとafterChangeの連携

両方のデリゲートを組み合わせることで、変更の検証と後処理を一連の流れで実装できます。

import kotlin.properties.Delegates

class Example {
    var count: Int by Delegates.vetoable(0) { _, old, new ->
        println("beforeChange: $old → $new")
        new >= 0 // 条件を満たさない場合は変更拒否
    }.observable(0) { _, old, new ->
        println("afterChange: $old → $new")
    }
}

fun main() {
    val example = Example()

    example.count = 5   // beforeChange → afterChange
    example.count = -1  // beforeChangeで拒否される
}

実行結果

beforeChange: 0 → 5  
afterChange: 0 → 5  
beforeChange: 5 → -1

まとめ

beforeChange：プロパティ変更前に条件を評価し、変更を拒否できる。
afterChange：変更後の処理を定義する。

これらを使い分けることで、柔軟かつ堅牢なプロパティ変更管理が可能となります。次のセクションでは、実際のユースケースを用いてobservableの活用例を紹介します。

実際のユースケース

observableやvetoableのデリゲートは、Kotlinのプロジェクトにおいてさまざまな場面で活用できます。ここでは、実際のユースケースを取り上げ、observableの利便性を具体的に解説します。

1. UIの自動更新

Androidアプリケーション開発では、データが変更された際にUIを自動的に更新する場面がよくあります。observableを使えば、プロパティ変更時にUI更新処理を容易に実装できます。

例：ViewModelでデータバインディングを行う

import kotlin.properties.Delegates

class ViewModel {
    var userName: String by Delegates.observable("未設定") { _, old, new ->
        println("ユーザー名が更新されました: $old → $new")
        // UIの更新処理をここで実装
    }
}

fun main() {
    val viewModel = ViewModel()
    viewModel.userName = "田中太郎" // UI更新が発生
    viewModel.userName = "山田花子" // 再度UI更新
}

2. 設定変更の追跡

アプリケーションの設定データが変更されたことを検知し、その変更を記録したり、他の機能へ反映する場面にも適しています。

例：設定データの変更をログに記録

import kotlin.properties.Delegates

class AppSettings {
    var theme: String by Delegates.observable("Light") { _, old, new ->
        println("テーマが変更されました: $old → $new")
        saveToLog("Theme changed from $old to $new")
    }

    private fun saveToLog(message: String) {
        // ログファイルへの保存処理（擬似的）
        println("ログ: $message")
    }
}

fun main() {
    val settings = AppSettings()
    settings.theme = "Dark" // 設定変更とログ記録
}

3. デバッグや変更履歴の記録

複数のプロパティの変更履歴を記録することで、デバッグや状態追跡が容易になります。

例：プロパティ変更履歴を管理

import kotlin.properties.Delegates

class Debuggable {
    var value: Int by Delegates.observable(0) { _, old, new ->
        println("変更履歴: $old → $new")
        history.add("Value changed from $old to $new")
    }

    val history = mutableListOf<String>()
}

fun main() {
    val debug = Debuggable()
    debug.value = 10
    debug.value = 20
    println("変更履歴: ${debug.history}")
}

実行結果

変更履歴: 0 → 10  
変更履歴: 10 → 20  
変更履歴: [Value changed from 0 to 10, Value changed from 10 to 20]

4. ゲームやシミュレーションの状態管理

ゲーム開発では、プレイヤーのスコアや状態が変更された際にイベントを発生させる処理が必要です。

例：プレイヤースコアの変更を監視

import kotlin.properties.Delegates

class Player {
    var score: Int by Delegates.observable(0) { _, old, new ->
        println("スコアが変更されました: $old → $new")
        if (new >= 100) println("おめでとう！スコア100点突破！")
    }
}

fun main() {
    val player = Player()
    player.score = 50
    player.score = 100
}

実行結果

スコアが変更されました: 0 → 50  
スコアが変更されました: 50 → 100  
おめでとう！スコア100点突破！

5. ビジネスロジックにおける入力検証

vetoableを使うことで、変更前に条件を確認し、無効なデータ入力を防ぐことが可能です。

例：入力値の検証

import kotlin.properties.Delegates

class User {
    var age: Int by Delegates.vetoable(0) { _, _, new ->
        new >= 0 // 年齢は0以上のみ許可
    }
}

fun main() {
    val user = User()
    user.age = 25
    println("年齢: ${user.age}")
    user.age = -5 // 無効な入力
    println("年齢: ${user.age}")
}

実行結果

年齢: 25  
年齢: 25

まとめ

observableおよびvetoableデリゲートは、UIの更新、状態変更の監視、入力検証、変更履歴の管理など、さまざまな場面で活用できます。これにより、Kotlinのプロパティ管理が効率的で柔軟になります。

次のセクションでは、Androidアプリ開発におけるライフサイクルとの統合について解説します。

ライフサイクルとの統合

Kotlinのobservableデリゲートは、Androidアプリ開発においてライフサイクルと統合することで、UIやデータの状態を適切に管理し、効率的な処理を実現できます。本セクションでは、ライフサイクルコンポーネントとobservableの連携方法について解説します。

ライフサイクルとは

Androidアプリでは、ActivityやFragmentの状態がライフサイクルに従って変化します。ライフサイクルは次の主要な状態に分けられます：

onCreate：初期化処理を行う。
onStart：画面が表示される直前。
onResume：画面が操作可能になる。
onPause：画面が操作不可になる直前。
onStop：画面が見えなくなる。
onDestroy：リソースの解放や終了処理を行う。

プロパティの変更検知（observable）をこれらの状態と統合することで、ライフサイクルに応じたデータ更新やUIの反映が可能です。

ViewModelとobservableの統合

Androidでは、ViewModelとobservableを組み合わせることで、UIコンポーネントの状態を効率的に管理できます。

例：ViewModelを使ったプロパティ変更とUIの反映

import androidx.lifecycle.ViewModel
import kotlin.properties.Delegates

class UserViewModel : ViewModel() {
    var userName: String by Delegates.observable("未設定") { _, old, new ->
        println("ユーザー名が更新されました: $old → $new")
        // LiveDataやUIに変更を通知する処理を記述
    }
}

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.lifecycle.ViewModelProvider

class MainActivity : AppCompatActivity() {
    private lateinit var userViewModel: UserViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        userViewModel = ViewModelProvider(this).get(UserViewModel::class.java)

        // ViewModelのプロパティを変更
        userViewModel.userName = "田中太郎"
    }
}

LiveDataとの併用

LiveDataを使用すれば、observableデリゲートで検知したプロパティの変更をUIへ自動的に通知できます。

例：LiveDataを用いた実装

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import kotlin.properties.Delegates

class UserViewModel : ViewModel() {
    private val _userName = MutableLiveData<String>("未設定")
    val userName: LiveData<String> get() = _userName

    var name: String by Delegates.observable("未設定") { _, _, new ->
        _userName.value = new
    }
}

Activity側のコード:

userViewModel.userName.observe(this) { name ->
    // UIに反映する処理
    textView.text = name
}

ライフサイクルイベントでの動作

observableデリゲートをActivityやFragmentのライフサイクルイベントに組み込むことで、特定の状態でのみデータを監視・更新できます。

例：onResumeとonPauseで監視処理を切り替える

override fun onResume() {
    super.onResume()
    userViewModel.name = "アクティブユーザー"
}

override fun onPause() {
    super.onPause()
    userViewModel.name = "非アクティブユーザー"
}

実際のシナリオ

データバインディング：observableでプロパティの変更を検知し、LiveDataを通じてUIに反映する。
状態保存：ライフサイクルイベント（onPauseやonStop）で現在の状態を保存し、再表示時に復元する。
UIパフォーマンス最適化：不要なデータ更新を避け、特定の状態でのみ処理を実行する。

まとめ

Kotlinのobservableデリゲートは、Androidアプリ開発においてライフサイクルと統合することで、データの変更監視、UIの自動更新、状態管理を効率化します。ViewModelやLiveDataと併用することで、アプリの品質と保守性を向上させることができます。

次のセクションでは、Delegated Propertiesのその他のデリゲートについて解説します。

Delegated Propertiesのその他のデリゲート

KotlinのDelegated Propertiesには、observable以外にも便利なデリゲートがいくつか標準ライブラリで提供されています。これらのデリゲートを適切に使い分けることで、コードの再利用性や効率性が向上します。

1. lazy

lazyは、プロパティの初回アクセス時にのみ値を計算し、それ以降はキャッシュされた値を返すデリゲートです。リソースの遅延初期化を実現するため、特に重い処理を遅らせる場合に役立ちます。

構文:

val value: String by lazy {
    println("値を初期化中...")
    "Hello, Lazy!"
}

使用例:

fun main() {
    println("まだ値にはアクセスしていません")
    println("値: $value") // 初回アクセス時に初期化
    println("値: $value") // 2回目以降はキャッシュを利用
}

出力結果:

まだ値にはアクセスしていません
値を初期化中...
値: Hello, Lazy!
値: Hello, Lazy!

2. vetoable

vetoableは、変更前に条件を検証し、変更を拒否するかどうかを決定できるデリゲートです。falseを返すとプロパティの変更はキャンセルされます。

構文:

import kotlin.properties.Delegates

var value: Int by Delegates.vetoable(0) { property, oldValue, newValue ->
    println("変更検証: $oldValue → $newValue")
    newValue >= 0 // 0以上の値のみ許可
}

使用例:

fun main() {
    println("初期値: $value")
    value = 10  // 許可される
    value = -5  // 拒否される
    println("最終値: $value")
}

出力結果:

初期値: 0
変更検証: 0 → 10
変更検証: 10 → -5
最終値: 10

3. Storing Properties in a Map（マップを利用したデリゲート）

プロパティの値をマップに保存し、動的にアクセスすることができます。特にJSONやデータベースからデータをロードする場合に便利です。

構文:

class User(val map: Map<String, Any?>) {
    val name: String by map
    val age: Int by map
}

使用例:

fun main() {
    val userData = mapOf("name" to "田中太郎", "age" to 25)
    val user = User(userData)

    println("名前: ${user.name}")
    println("年齢: ${user.age}")
}

出力結果:

名前: 田中太郎
年齢: 25

4. Custom Delegate（独自デリゲート）

Kotlinでは独自のデリゲートを作成することも可能です。独自デリゲートはgetValueとsetValue関数を実装することで定義できます。

使用例:

import kotlin.reflect.KProperty

class CustomDelegate {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return "プロパティ '${property.name}' の値を取得しました"
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("プロパティ '${property.name}' に '$value' を設定しました")
    }
}

class Example {
    var myProperty: String by CustomDelegate()
}

fun main() {
    val example = Example()
    println(example.myProperty) // getValueが呼ばれる
    example.myProperty = "新しい値" // setValueが呼ばれる
}

出力結果:

プロパティ 'myProperty' の値を取得しました
プロパティ 'myProperty' に '新しい値' を設定しました

まとめ

KotlinのDelegated Propertiesは、observable以外にもlazy、vetoable、マップベースのデリゲート、カスタムデリゲートなど、さまざまな機能を提供します。これらを活用することで、データ管理やプロパティの動作を柔軟に制御し、コードをより簡潔かつ効率的に記述することができます。

次のセクションでは、理解を深めるために演習問題としてobservableの実装を試してみましょう。

演習問題：observableの実装

ここでは、Delegates.observableを使ったプロパティ変更検知の理解を深めるために、実際に手を動かして試せる演習問題を紹介します。

問題1: プロパティの変更履歴を記録する

目的: observableデリゲートを使い、プロパティの変更履歴を記録して表示するプログラムを作成してください。

要件:

Userクラスにnameプロパティを定義する。
プロパティの変更を検知し、変更前と変更後の値をリストに記録する。
記録した履歴を出力する機能を追加する。

サンプルコード（穴埋め形式）:

import kotlin.properties.Delegates

class User {
    val history = mutableListOf<String>()
    var name: String by Delegates.observable("未設定") { _, old, new ->
        __________  // ここに変更履歴を追加するコードを書く
    }
}

fun main() {
    val user = User()
    user.name = "田中太郎"
    user.name = "山田花子"
    user.name = "佐藤次郎"

    println("変更履歴:")
    user.history.forEach { println(it) }
}

問題2: 無効な値を拒否するプロパティの実装

目的: Delegates.vetoableを使って、プロパティに無効な値が設定されないようにします。

要件:

Userクラスにageプロパティを定義する。
年齢が0未満の場合は変更を拒否するようにする。
年齢の変更が許可された場合のみ、変更内容を出力する。

サンプルコード（穴埋め形式）:

import kotlin.properties.Delegates

class User {
    var age: Int by Delegates.vetoable(0) { _, old, new ->
        println("年齢の変更: $old → $new")
        __________  // ここに拒否する条件を書く（0未満の場合にfalseを返す）
    }
}

fun main() {
    val user = User()
    user.age = 25
    user.age = -5
    user.age = 30

    println("最終的な年齢: ${user.age}")
}

問題3: ゲームのプレイヤーステータスを管理する

目的: observableを使って、ゲームのプレイヤーステータスが変更されるたびに通知を行います。

要件:

Playerクラスにhealth（体力）プロパティを定義する。
体力が変更されるたびに、変更前後の値を表示する。
体力が0になった場合、「ゲームオーバー」 と表示する。

サンプルコード（穴埋め形式）:

import kotlin.properties.Delegates

class Player {
    var health: Int by Delegates.observable(100) { _, old, new ->
        println("体力が変更されました: $old → $new")
        __________  // 体力が0になったら「ゲームオーバー」を表示する条件を書く
    }
}

fun main() {
    val player = Player()
    player.health = 80
    player.health = 50
    player.health = 0
}

解答のポイント

問題1: history.add("変更: $old → $new") のように履歴を追加します。
問題2: new >= 0 のように条件を満たす場合のみtrueを返します。
問題3: if (new == 0) println("ゲームオーバー") のように条件を追加します。

演習を終えて

これらの問題を解くことで、Kotlinのobservableおよびvetoableデリゲートの基本的な使い方が身につきます。各問題を手元で動かしてみることで、変更検知やデータの状態管理に関する理解が深まるでしょう。

次のセクションでは、本記事のまとめを行います。

まとめ

本記事では、KotlinにおけるDelegated Propertiesを活用したプロパティ変更検知の方法について解説しました。特に、observableデリゲートを使用することでプロパティの変更を簡単に検知し、コールバックで処理を追加できる仕組みを学びました。

また、以下のポイントについても詳しく触れました：

Delegated Propertiesの概要
observableの基本的な使い方とコールバックの仕組み
beforeChangeやafterChangeの動作の違いと活用法
UI更新や状態管理など、実際のユースケース
vetoableやlazyなど、その他のデリゲートの活用例

最後に、演習問題を通じてobservableの実装や条件付き変更管理について実践的に学びました。これらの機能を活用することで、プロパティの状態を効率的に管理し、シンプルで拡張性のあるKotlinコードを実装できるようになります。

KotlinのDelegated Propertiesは強力で柔軟な機能です。開発するアプリケーションの要件に応じてobservableやvetoableを適切に使い分け、プロジェクトの品質向上に役立ててください。

KotlinのDelegated Propertiesを使ったプロパティ変更検知方法を徹底解説

Delegated Propertiesとは何か

Delegated Propertiesの基本的な仕組み

標準ライブラリで提供されるデリゲート

Delegated Propertiesのメリット

observableデリゲートの概要

observableデリゲートの仕組み

observableの動作例

observableの用途

observableの基本的な使い方

基本的なコード例

実行結果

複数のobservableプロパティを定義

実行結果

observableを活用した状態の管理

beforeChangeとafterChangeの動作

beforeChangeの概要

実行結果

afterChangeの概要

実行結果

beforeChangeとafterChangeの使い分け

beforeChangeとafterChangeの連携

実行結果

まとめ

実際のユースケース

1. UIの自動更新

2. 設定変更の追跡

3. デバッグや変更履歴の記録

実行結果

4. ゲームやシミュレーションの状態管理

実行結果

5. ビジネスロジックにおける入力検証

実行結果

まとめ

ライフサイクルとの統合

ライフサイクルとは

ViewModelとobservableの統合

LiveDataとの併用

ライフサイクルイベントでの動作

実際のシナリオ

まとめ

Delegated Propertiesのその他のデリゲート

1. lazy

2. vetoable

3. Storing Properties in a Map（マップを利用したデリゲート）

4. Custom Delegate（独自デリゲート）

まとめ

演習問題：observableの実装

問題1: プロパティの変更履歴を記録する

問題2: 無効な値を拒否するプロパティの実装

問題3: ゲームのプレイヤーステータスを管理する

解答のポイント

演習を終えて

まとめ

コメント

コメントする コメントをキャンセル

コメントするコメントをキャンセル