【Flutter】Dartから入るオブジェクト指向プログラミング入門

Flutterからプログラミングを学び始めた人が、オブジェクト指向プログラミング(OOP)の考え方をさらっと学習するために本記事を執筆します。
間違いや分かりずらい点ありましたらご指摘お願いします:bow:

# サンプルプロジェクトの簡単な説明
Flutterプロジェクト作成時の初期アプリであるカウントアップアプリに機能追加したものになります。
カウンターの種類を変えることができ、0,1,2,・・・と進んでいき値が12になったらまた0に戻るHourCounterと単純に0から無限にカウントアップしていくSimpleCounterを左上のスイッチで切り替えることが出来ます。
<img src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/141823/80ff799d-f93d-ecfb-b7f3-2ba87e304551.gif" width=400> 

ついでに、スイッチの状態は一度アプリを切っても保持されます(shared_preferencesを使用)

カウンターのクラス図は以下のようになっています。
※きちんとしたUMLの記法で書いていません。あくまでイメージとしてとらえてください。
![サンプルクラス図.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/141823/bafbac42-a906-e9ea-b453-c378c6dbe694.png)

以下にコードを置いています

https://github.com/tokku5552/flutter_oop_recture

※レクチャーの綴り間違えました...作り直すの面倒くさいのでそのまま...

# オブジェクト指向基礎
手続き型言語のコード量の多さや、保守性の悪さを解決する、プログラミング言語のアーキテクチャの一つ。
データと操作をまとめて一つのオブジェクトとしてとらえる。
オブジェクト指向の3大要素として「カプセル化、継承、ポリモーフィズム」がある。

## クラスとメンバ
クラスとはオブジェクトを生成するためにデータと処理を定義したもの。
データのことを**フィールド**といい、処理のことを**メソッド**という。
フィールドとメソッドのことを**メンバ**という。メンバと言われたら、フィールドかメソッドのこと。
クラスを実際にオブジェクトにして使うことを**インスタンス化**と言い、生成されたものをインスタンスと呼ぶ。
Dartではnewをつけてもつけなくても良い。

```dart:class_example.dart
class Hoge {
  // フィールド
  String value;

  // メソッド
  void fuga() {
    value = 'piyo';
  }
}
```


## アクセス修飾子
メンバにはアクセス制限をつけることが出来る。Javaのようにpublic、protected、privateのようなキーワードはなく、
**Dartでは名前の頭に_(アンダースコア)をつけるとprivateとなる**。
privateなメンバはクラス外からアクセスできない。(可視性の制御)

```dart:counter_model.dart
class CounterModel extends ChangeNotifier {
  ...

  // このcount自体はpublicなので外部から見える
  int get count => _counter?.counter;
  bool isChangedHourCounter = true;

  // _counterと_counterTypeは_がついているのでprivate
  CounterBase _counter;
  CounterType _counterType;

  ...

```

## その他の修飾子
### var
通常の変数指定。型を指定しない場合につける。指定しない場合でもDartの場合型推論を行う。
個人的には基本使用せず、型を指定すべきかと思う。(型が決まっていない場合はdynamicを使うようにする)

### final
再代入不可となるが、参照先の内容は書き換えることが出来る。

```dart:finalの例
final String hoge = 'hoge';
hoge = 'fuga'; // NG

final List<String> piyo = ['piyo','piyopiyo'];
piyo[0] = 'piyopiyopiyo'; // OK 内容は書き換えられる
```

### const
finalと似ているが、コンパイル時に値が決まっていることを保証する。
また、finalと違って参照先の内容を書き換えることも出来ない。

```dart:constのイメージ
const String hoge = 'fuga';
print('hoge is ${hoge}');
// ↓コンパイル時に以下に変換されるイメージ
print('hoge is fuga');

```

### static
指定したクラス内のフィールドがインスタンスごとに保持されるのではなく、クラスで1つの実体を持つことを宣言する。
コンストラクタを用いたインスタンス化を行わなくても、ダイレクトに参照できるようになる。

```dart:staticの例
class Hoge {
  static String fuga = 'piyo';
}

main() {
  print(Hoge.fuga); // piyo
}

```


参考：[Dartの変数定義時の修飾static/final/const、そしてconst constructorについて - Qiita](https://qiita.com/uehaj/items/7c07f019e05a743d1022)


## カプセル化
アクセス修飾子を使って外部から見えるメンバを制限すること。
内部で何が行われているかを隠蔽し、使いやすくする。

## コンストラクタ
インスタンス化するときに呼ばれるメソッド。クラス内に定義しない場合、自動的に作成されたデフォルトコンストラクタが呼ばれる。
Dartでは他の言語のようにオーバーロード(同名で、受け取る値が異なるコンストラクタを複数定義し、インスタンス化するときに渡す変数を変えることで、生成されたオブジェクトを変化させる機能)は出来ないが、名前付きコンストラクタという機能で同じようなことが出来る。

```dart:コンストラクタの例
class CounterModel extends ChangeNotifier {
  // クラス名と同じ名前でコンストラクタを作る
  // メソッド全般の話だが、{}の中に引数を書くことで、使う時に変数名を参照できる
  // 下の例だと使う時、CounterModel(storageRepository: hoge)のようになる
  CounterModel({@required StorageRepositoryBase storageRepository})
      : _storageRepository = storageRepository;

  // クラス内のフィールドをfinal(以降変更できない)とするときはコンストラクタ内で初期化するか
  // 宣言と同時に初期化する必要がある
  final StorageRepositoryBase _storageRepository;

```

以下は名前付きコンストラクタの例だが、_で始まっているのでprivateとなる

```dart:名前付きコンストラクタの例
class PersistenceStorageProvider {
  PersistenceStorageProvider._();

  static final PersistenceStorageProvider instance =
      PersistenceStorageProvider._();
```

## 抽象クラスとインターフェース
いきなりDartでの仕様を学ぼうとすると混乱するので、一般的な話をする。
抽象クラスとは**abstract**というキーワードを**class**キーワードの前につけたクラスのことで、継承されることを前提として設計される。
継承とはすでに存在しているクラスに、メンバを追加したり元々のメソッドを上書きしたりして新しいクラスを作ること。
継承元のクラスを**スーパークラス**と言い、継承して出来たクラスを**サブクラス**という。
抽象クラスは**処理の再利用をしたいとき**に使う。
一方インターフェースは使えるメソッドを定義するためのもの。インターフェースを実装したクラスは、**インターフェース内で定義されているメソッドがオーバーライドされていることが保証される**。

参考：[【詳解】抽象クラスとインタフェースを使いこなそう！！ - Qiita](https://qiita.com/yoshinori_hisakawa/items/cc094bef1caa011cb739)


## Dartにおける抽象クラスと暗黙的インターフェース
Dartではinterfaceといったキーワードは使えないが、代わりに全てのクラスは**暗黙的に自動でinterfaceが定義される**。
継承したいときは**extends**を使い、実装したいとき(インターフェースとして使いたいとき)は**implements**を使用する。
abstractクラスをextendsした場合でもimplementsした場合でも**スーパークラスで定義されているメソッドはすべてオーバーライドする必要がある**。
違いとしては、extendsの場合、abstractクラスで定義した**フィールドの利用が可能**であり、メソッドの実装までabstract側でやっておいて、**superとして処理を呼べる**。（処理の共通化）

```dart:counter_base.dart
/// Counterの基本となる抽象クラス
/// フィールドにはcounterを持ち
/// incrementというcounterをインクリメントするメソッドの
/// 実装を強制する
abstract class CounterBase {
  int counter = 0;
  void increment();
}
```
以下が継承したサブクラス

```dart:simple_counter.dart
import 'package:flutter_oop_recture/domain/counter_base.dart';

class SimpleCounter extends CounterBase {

  // @override のアノテーションをつけてメソッドをオーバーライドする
  @override
  void increment() {
    // SimpleCounter自体のフィールドにcounterというものはないが
    // スーパークラスのフィールドを使用できる
    super.counter++;
  }
}
```




一方**implements**の場合、**変数を定義できず**、superとして処理も呼べないため、必ずメソッドの実装をオーバーライドして書き換える必要がある。

```dart:storag_repository_base.dart
// abstract として定義しているが、目的はinterfaceとしての利用
abstract class StorageRepositoryBase {
  Future<void> savePersistenceStorage(String key, String value);
  Future<String> loadPersistenceStorage(String key);
  Future<bool> isExistKey(String key);
  Future<void> remove(String key);
}
```

以下が実装クラス

```dart:storage_repository.dart
class StorageRepository implements StorageRepositoryBase {
  final PersistenceStorageProvider _instance =
      PersistenceStorageProvider.instance;

  @override
  Future<void> savePersistenceStorage(String key, String value) async {
    final SharedPreferences pref = await _instance.prefs;
    await pref.setString(key, value);
  }

  // 他すべてのメソッドをオーバーライド
  ...

```


参考：[【Dart】abstract,mixin,extends,implements,with等の使い方基礎 - Zenn](https://zenn.dev/iwaku/articles/2020-12-16-iwaku)


## ポリモーフィズム
ポリモーフィズム(多態性)とはクラスを継承してメソッドをオーバーライドしたことで、同名のメソッドを呼んだ時に挙動が変わることです。

先ほども紹介したCounterBaseの抽象クラスですが、**increment**というメソッドを持っています。

```dart:counter_base.dart
abstract class CounterBase {
  int counter = 0;
  void increment();
}
```

SimpleCounterでは単純にインクリメントを行うだけに対し

```simple_counter.dart
class SimpleCounter extends CounterBase {
  @override
  void increment() {
    super.counter++;
  }
}
```

HourCounterではincrementメソッドの中でresetメソッドを呼び、もし指定したmodular(法)の数になったら、値を0にリセットする処理を、スーパークラスのModularCounterで実装しています。

```dart:modular_counter.dart
abstract class ModularCounter extends CounterBase {
  ModularCounter(this.modular);
  final int modular;

  /// ModularCounterにはリセット機能を実装するよう強制する
  /// スーパークラスのcounterを用いて実装しておく
  void reset() {
    // 明示的にsuper.counterと書かなくとも、スーパークラスのフィールドが使える
    if (counter >= modular) {
      counter = 0;
    }
  }
}
```

このModularCounterを継承することで、resetメソッドを呼び出すことが出来ます。

```dart:hour_counter.dart
class HourCounter extends ModularCounter {
  HourCounter() : super(12);

  @override
  void increment() {
    super.counter++;
    reset();
  }

  @override
  void reset() {
    // reset機能はスーパークラスの実装をそのまま使うため
    // 内部でsuper.reset()を呼ぶだけにしておく
    super.reset();
  }
}
```

## 依存関係逆転の原則

このようにextendsやimplementsを行って作ったクラスを使う時に注意すべきなのが**依存関係逆転の原則**です。
CounterBaseを継承して作られたSimpleCounterを使いたい場合に、SimpleCounterをそのまま宣言してしまうとSimpleCounterに依存してしまうことになります。
そうではなく、もっと抽象的な存在であるCounterBaseに依存させることで、後からHourCounterに差し替えることが可能になります。

```dart:counter_model.dart
class CounterModel extends ChangeNotifier {
  ...

  CounterBase _counter;
  CounterType _counterType;

  ...

  /// _counterをCounterBaseとして定義しているので
  /// 後からSimpleCounterやHourCounterに差し替えることが出来る
  Future<void> switchCounter() async {
    if (isChangedHourCounter) {
      _counter = SimpleCounter();
      isChangedHourCounter = false;
      await _storageRepository.savePersistenceStorage(
          key_counter, CounterType.simpleCounter.value);
    } else {
      _counter = HourCounter();
      isChangedHourCounter = true;
      await _storageRepository.savePersistenceStorage(
          key_counter, CounterType.hourCounter.value);
    }
    notifyListeners();
  }

  /// CounterBaseにはincrementメソッドを定義しているので、気にせずincrementを呼ぶことが出来る
  /// 実際に行われる処理は具体的に実装されたSimpleCounterやHourCounterで実装したincrementメソッド
  void increment() {
    _counter.increment();
    notifyListeners();
  }
}

```

上記のケースでは単にカウンターの切替を行うだけですが、結局CounterModelがSimpleCounterとHourCounterに依存してしまっています。
そこで、このような依存関係をなくすために、外部から実装クラスを受け取るように実装したくなる時があります。
そのような手法を**DI(Dependency Injection)**と言います。

CounterModelではコンストラクタからStorageRepositoryBase(インターフェース)を受け取っており、内部ではどのような実装が行われているかは意識しません。

```dart:counter_model.dart
class CounterModel extends ChangeNotifier {
  CounterModel({@required StorageRepositoryBase storageRepository})
      : _storageRepository = storageRepository;

  final StorageRepositoryBase _storageRepository;
```

これを外から代入する方法は様々ですが、FlutterではProviderパッケージを使って代入を行うことが出来ます。

```dart:main.dart
void main() {
  runApp(
    MultiProvider(
      providers: [
        // 後から読み込む場合の型はStorageRepositoryBase(インターフェース)
        Provider<StorageRepositoryBase>(
          // 実際に生成しているのはStorageRepository(StorageRepositoryのサブクラス)
          create: (BuildContext context) => StorageRepository(),
        ),
        ChangeNotifierProvider<CounterModel>(
          create: (BuildContext context) => CounterModel(
              // 上記で生成したStorageRepositoryBaseを型に持つ実体をCounterModelのコンストラクタへ代入
              storageRepository: context.read<StorageRepositoryBase>())
            ..init(),
        ),
      ],
      child: MyApp(),
    ),
  );
}
```

参考：[オブジェクト指向　依存関係逆転の原則の「逆転」とは - Qiita](https://qiita.com/sizukutamago/items/2f0d99043924f19c4f21)

## シングルトン
生成したインスタンスが単一であることを保証するもの。
状態を保持したいときや、何度も同じ処理を行いたくないときに使う。
サンプルプロジェクトではshared_preferencesのインスタンスを提供するクラスをシングルトンで定義している。

```dart:persistence_storage_provider.dart
class PersistenceStorageProvider {
  PersistenceStorageProvider._();

  // staticとすることでインスタンスごとに保持されるのではなく、クラスで1つの実体を持つことを宣言する
  // instanceという変数への参照に自分自身を代入している
  static final PersistenceStorageProvider instance =
      PersistenceStorageProvider._();
  
  // 内部で保持しておきたいインスタンス　
  SharedPreferences _prefs;

  Future<SharedPreferences> get prefs async {
    // ??=を使ってもし_prefがnullならば右辺の結果を代入し、そうでなければそのまま_prefを返却する
    return _prefs ??= await initSharedPreferences();
  }

  // 実際にSharedPreferencesのインスタンスを取得する処理
  Future<SharedPreferences> initSharedPreferences() async {
    final SharedPreferences prefs = await SharedPreferences.getInstance();
    return prefs;
  }
}
```


参考：

- [Dartの変数定義時の修飾static/final/const、そしてconst constructorについて - Qiita](https://qiita.com/uehaj/items/7c07f019e05a743d1022)
- [【Flutter】Dartでシングルトンパターンを実装する - taketiyo.log](https://tkzo.jp/blog/dart-singleton-pattern/)


## おまけ Unit Test
依存関係逆転の法則を用いてCounterModelからSharedPreferencesの依存を排除したことによって、単体テストが書きやすくなる。単体テストの書き方については[過去の記事](https://qiita.com/tokkun5552/items/7af34769104e94f50745)を参照してください。

```dart:counter_model_test.dart
void main() {
  // テスト用のメソッドを使いたいので、型はテスト用repositoryの方を指定する
  final StorageMemRepository storageRepository = StorageMemRepository();
  group('init', () {
    test('shared_preferencesに値がない場合', () async {
      storageRepository.clear();
      // ここでCounterModelを生成しているが、渡しているのは初めに定義したテスト用のインスタンス
      final model = CounterModel(storageRepository: storageRepository);
      await model.init();

      // isChangeHourCounterは初期状態のtrueのままであること
      expect(model.isChangedHourCounter, true);
      model.dispose();
    });

    test('shared_preferencesにSimpleCounterが設定してある場合', () async {
      storageRepository.clear();
      // あらかじめsimpleCounterの方をセットしておく
      await storageRepository.savePersistenceStorage(
          key_counter, CounterType.simpleCounter.value);
      final model = CounterModel(storageRepository: storageRepository);
      await model.init();

      // isChangeHourCounterはfalseであること
      expect(model.isChangedHourCounter, false);
      model.dispose();
    });
  });
  ...

```

テスト用のレポジトリは以下のようにインメモリで動作するように記載している。
StorageRepositoryBaseをimplementsしているので、CounterModelのコンストラクタで代入出来る。

```dart:storage_mem_repository.dart
class StorageMemRepository implements StorageRepositoryBase {
  // テスト用のレポジトリ内のデータの実態はただのMap
  final Map<String, String> _data = <String, String>{};

  // データを初期化できるようにテスト用リポジトリだけclearメソッドを追加
  void clear() {
    _data.clear();
  }

  // その他のメソッドは実際にSharedPreferencesにアクセスせずに
  // 単に_dataを操作するように書く
  @override
  Future<bool> isExistKey(String key) {
    return Future<bool>.value(_data[key] != null);
  }
  ...
}

```
## Next Action
オブジェクト指向が何となくわかってきたら、アーキテクチャについて学ぶと良いと思います。
FlutterではMVVM + RepositoryやDDDがよく使われます。

- ProviderでMVVM + Repositoryを使った解説はこちら
    - [TodoアプリをProviderを使ってFlutterで作る | インフラエンジニアがもがくブログ](https://tokku-engineer.tech/todoapp-provider-flutter/)
- Riverpodを使ったDDDについてはこちら
    - [【Flutter】hooks_riverpod+state_notifier+freezedでのドメイン駆動設計 - Qiita](https://qiita.com/tokkun5552/items/5dcb79e5283a67c2b2fe)

# まとめ
書く中で色々調べなおして整理したりしたので自分自身の勉強にもなりました。
プログラミング初心者に向けてのつもりで書き始めたけど、初心者を抜け出して中級者になろうとしている人や中級者が読むといいのかもしれないと思いました。


## 参考

- [tokku5552/flutter_oop_recture - GitHub](https://github.com/tokku5552/flutter_oop_recture)
- [【詳解】抽象クラスとインタフェースを使いこなそう！！ - Qiita](https://qiita.com/yoshinori_hisakawa/items/cc094bef1caa011cb739)
- [【Dart】abstract,mixin,extends,implements,with等の使い方基礎 - Zenn](https://zenn.dev/iwaku/articles/2020-12-16-iwaku)
- [オブジェクト指向　依存関係逆転の原則の「逆転」とは - Qiita](https://qiita.com/sizukutamago/items/2f0d99043924f19c4f21)
- [Dartの変数定義時の修飾static/final/const、そしてconst constructorについて - Qiita](https://qiita.com/uehaj/items/7c07f019e05a743d1022)
- [【Flutter】Dartでシングルトンパターンを実装する - taketiyo.log](https://tkzo.jp/blog/dart-singleton-pattern/)
- [【Flutter】Providerで最低限のDIを行ってテスタブルなコードにリファクタリングする - Qiita](https://qiita.com/tokkun5552/items/7af34769104e94f50745)
- [Flutterで単体テストを書く - Qiita](https://qiita.com/tokkun5552/items/ede8460bef4892f48e37)
- [Dartの変数定義時の修飾static/final/const、そしてconst constructorについて - Qiita](https://qiita.com/uehaj/items/7c07f019e05a743d1022)
- [Flutterに関する記事まとめ | インフラエンジニアがもがくブログ](https://tokku-engineer.tech/flutter-all-article/)