デザインパターン　Factoryパターン

# Factoryパターン
**Creational Design Pattern** の一つで、クライアントに対してインスタンスの生成を隠蔽するためのパターン。

具象クラスのインスタンス化を隠蔽またはカプセル化することで、クライアントは直接クラスを`new`演算子によってインスタンス化するのではなく、ファクトリーに生成を依頼するようになる。

これにより、クライアントコードから具象クラスがなくなり、「**変更に対しては閉じられているが、拡張に対しては開かれている**」状態となる。

Factoryパターンには以下の３種類が存在する。
+ Simple Factory
+ Factory Method
+ Abstract Factory

## Simple Factory
厳密にはGoF（Gang of Four）によって定義されるデザインパターンではないが、クライアントから具象クラスを分離させるための一つのスタイルである。

インスタンスを返却するメソッドがコンストラクタの役割を果たすことにより、具象クラスのインスタンス化をカプセル化する。

どの具象クラスをインスタンス化するのかを、クライアントがメソッドの引数（パラメータ）によって決定する。

クラスが Factory （インスタンス生成）の役割を果たす。

:::note info
生成する具象クラスを、**クライアントが選択する**
**クラス**が Factory
:::

### Simple Factoryの例
生成するオブジェクトは、現時点で`JapaneseFood`、`FrenchFood`、`ChineseFood`の3種類が存在し、それぞれ`Food`インターフェースを実装しているものとする。

これらのオブジェクトは`Resutaurant`クラス（`Food`のクライアントに相当）で利用されていて、注文に応じて3種類の中から1つを選択して`cook()`が実行される。
![SimpleFactory.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1069520/a681b79b-9209-6fe7-a494-d017657d408e.png)
```java:Food.java
// Factory で生成されるクラスのインターフェース
public interface Food {
    public void cut();
    public void addSalt();
    public void addSugar();
}
```

```java:JapaneseFood.java
// Factory で生成される具象クラス①
public class JapaneseFood implements Food {

    @Override
    public void cut() {
        System.out.println("食材を千切りします。");
    }

    @Override
    public void addSalt() {
        System.out.println("塩を5g加えます。");
    }

    @Override
    public void addSugar() {
        System.out.println("砂糖を5g加えます。");
    }
}
```

```java:FrenchFood.java
// Factory で生成される具象クラス②
public class FrenchFood implements Food {

    @Override
    public void cut() {
        System.out.println("食材を乱切りします。");
    }

    @Override
    public void addSalt() {
        System.out.println("塩を1g加えます。");
    }

    @Override
    public void addSugar() {
        System.out.println("砂糖を1g加えます。");
    }
}
```

```java:ChineseFood.java
// Factory で生成される具象クラス③
public class ChineseFood implements Food {

    @Override
    public void cut() {
        System.out.println("食材を輪切りします。");
    }

    @Override
    public void addSalt() {
        System.out.println("塩を10g加えます。");
    }

    @Override
    public void addSugar() {
        System.out.println("砂糖を10g加えます。");
    }
}
```

```java:Restaurant.java
// Factory を利用する、クライアントに当たるクラス
public class Restaurant {

    FoodFactory factory;

    public Restaurant(FoodFactory factory) {
        this.factory = factory;
    }

    public void cook() {
        // new が使用されていない
        // クライアントが具象クラスを選択している
        Food food = factory.createFood("japanese");
        food.cut();
        food.addSalt();
        food.addSugar();
    }
}
```

```java:FoodFactory.java
// Factory クラス
// 具象クラスのインスタンス化がここに集約・カプセル化、隠蔽されている
public class FoodFactory {
    // static にしてもOK（ただし static の場合、継承による機能拡張ができない）
    public Food createFood(String type) {
        if (type.equals("japanese")) {
            return new JapaneseFood();
        } else if (type.equals("chinese")) {
            return new ChineseFood();
        } else if (type.equals("french")) {
            return new FrenchFood();
        } else {
            throw new IllegalArgumentException();
        }
    }
}
```

```java:Main.java
public class Main {
    public static void main(String[] args) {
        Restaurant restaurant = new Restaurant(new FoodFactory());
        restaurant.cook();
        // >>食材を千切りします。
        // >>塩を5g加えます。
        // >>砂糖を5g加えます。
    }
}
```

Simple Factory を利用したことで、クライアントのプログラムコードから具象クラスが消え、クライアントが具象クラスにではなく、インターフェースに依存するようになった（**具象クラスに依存するよりも、抽象クラスに依存する**プログラミングが良いとされる）。

## Factory Method

インスタンス生成するメソッド（ Factory ）をスーパークラスの抽象メソッドなどで定義し、**継承**したサブクラスが実際にどの具象クラスをインスタンス化するのかを実装する。ただし、どの Factory を利用するかの選択はクライアントが行う。

:::note info
生成する具象クラスを、**サブクラスが選択する**
使用する Factory は、**クライアントが選択する**
**メソッド**が Factory（一つのメソッドが一つのオブジェクトを生成する）
**継承**を利用する
:::

メソッドが Factory （インスタンス生成）の役割を果たす。

### Factory Method の利用例
![FactoryMethod.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1069520/181a604a-9652-bbca-dbab-1d86bd8782ed.png)

`Food`インターフェースを実装した、以下の6つの具象クラスが存在するとする。
+ `CasualJapaneseFood`
+ `CasualChineseFood`
+ `CasualFrenchFood`
+ `LuxuriousJapaneseFood`
+ `LuxuriousChineseFood`
+ `LuxuriousFrenchFood`

これらの具象クラスを生成するメソッドは`createFood()`だが、`japanese`が指定された時に`CasualJapaneseFood`を生成する Factory と、`LuxuriousJapaneseFood`を生成する Factory が必要になる。

そこで、Factory （インスタンス生成を行うメソッド）をスーパークラスの抽象メソッド（`createFood()`）として用意して、サブクラス`CasualRestaurant`とサブクラス`LuxuriousRestaurant`で実装する。

クライアントはまず、以下の２つの選択を行う。
+ `japanese` or `chinese` or `french`　（この選択は必須ではない）
+ `CasualRestaurant` or `LuxuriousRestaurant`　（Factoryの選択）


選択された Restaurant は、具象クラス6つの中から一つを選択して、インスタンスの生成を行う。例えば、`japanese`、`CasualRestaurant`が選択された場合、`CasualJapaneseFood`の生成を行う。

ここで重要なのは、クライアントは Simple Factory と同様に、具象クラスの選択をしていないということ。あくまでも**具象クラスの選択はサブクラスが行なっていて、クライアントは Factory の選択をしている**。

```java:Food.java
public interface Food {
    public void cut();
    public void addSalt();
    public void addSugar();
}
```

```java:CasualJapaneseFood.java
// 具象クラス①
public class CasualJapaneseFood implements Food {
    @Override
    public void cut() { System.out.println("普通の包丁で、食材を千切りします。"); }
    @Override
    public void addSalt() { System.out.println("普通の塩を、5g加えます。"); }
    @Override
    public void addSugar() { System.out.println("普通の砂糖を、5g加えます。"); }
}
```

```java:CasualChineseFood.java
// 具象クラス②
public class CasualChineseFood implements Food {
    @Override
    public void cut() { System.out.println("普通の包丁で、食材を千切りします。"); }
    @Override
    public void addSalt() { System.out.println("普通の塩を、5g加えます。"); }
    @Override
    public void addSugar() { System.out.println("普通の砂糖を、5g加えます。"); }
}
```

```java:CasualFrenchFood.java
// 具象クラス③
public class CasualFrenchFood implements Food {
    @Override
    public void cut() { System.out.println("普通の包丁で、食材を乱切りします。"); }
    @Override
    public void addSalt() { System.out.println("普通の塩を、1g加えます。"); }
    @Override
    public void addSugar() { System.out.println("普通の砂糖を、1g加えます。"); }
}
```

```java:LuxuriousJapaneseFood.java
// 具象クラス④
public class LuxuriousJapaneseFood implements Food {
    @Override
    public void cut() { System.out.println("高級な包丁で、食材を千切りします。"); }
    @Override
    public void addSalt() { System.out.println("高級な塩を、5g加えます。"); }
    @Override
    public void addSugar() { System.out.println("高級な砂糖を、5g加えます。"); }
}
```

```java:LuxuriousChineseFood.java
// 具象クラス⑤
public class LuxuriousChineseFood implements Food {
    @Override
    public void cut() { System.out.println("高級な包丁で、食材を輪切りします。"); }
    @Override
    public void addSalt() { System.out.println("高級な塩を、10g加えます。"); }
    @Override
    public void addSugar() { System.out.println("高級な砂糖を、10g加えます。"); }
}
```

```java:LuxuriousFrenchFood.java
// 具象クラス⑥
public class LuxuriousFrenchFood implements Food {
    @Override
    public void cut() { System.out.println("高級な包丁で、食材を乱切りします。"); }
    @Override
    public void addSalt() { System.out.println("高級な塩を、1g加えます。"); }
    @Override
    public void addSugar() { System.out.println("高級な砂糖を、1g加えます。"); }
}
```

```java:Restaurant.java
// スーパークラス
public abstract class Restaurant {

    public void cook(String type) {
        Food food = createFood(type);
        food.cut();
        food.addSalt();
        food.addSugar();
    }

    // ⭐️ Factory Method （インスタンスを生成するメソッド） ⭐️
    // ただし、抽象メソッドのため、実装はサブクラスが行う（デフォルトメソッドとしてもOK）
    // Restaurant は実際にどの具象クラスが生成されるかを知らない。Restaurant を利用するクライアントも知らない。
    protected abstract Food createFood(String type);
}
```

```java:CasualRestaurant.java
// サブクラス①
public class CasualRestaurant extends Restaurant {
    // サブクラスが生成する具象クラスを選択する
    @Override
    protected Food createFood(String type) {
        if (type.equals("japanese")) {
            return new CasualJapaneseFood(); // 具象クラス①
        } else if (type.equals("chinese")) {
            return new CasualChineseFood(); // 具象クラス②
        } else if (type.equals("french")) {
            return new CasualFrenchFood(); // 具象クラス③
        } else {
            throw new IllegalArgumentException();
        }
    }
}
```

```java:LuxuriousRestaurant.java
// サブクラス②
public class LuxuriousRestaurant extends Restaurant {
    // サブクラスが生成する具象クラスを選択する
    @Override
    protected Food createFood(String type) {
        if (type.equals("japanese")) {
            return new LuxuriousJapaneseFood(); // 具象クラス④
        } else if (type.equals("chinese")) {
            return new LuxuriousChineseFood(); // 具象クラス⑤
        } else if (type.equals("french")) {
            return new LuxuriousFrenchFood(); // 具象クラス⑥
        } else {
            throw new IllegalArgumentException();
        }
    }
}
```

```java:Main.java
// クライアント
public class Main {
    public static void main(String[] args){
        // クライアントは Factory の選択をするが、どの具象クラスが生成されるかを知らない
        Restaurant restaurant = new CasualRestaurant();
        restaurant.cook("japanese");
        // >>普通の包丁で、食材を千切りします。
        // >>普通の塩を、5g加えます。
        // >>普通の砂糖を、5g加えます。
    }
}
```

## Abstract Factory

複数の関連するオブジェクト（オブジェクト群、Family）を、**コンポジション**によって保持された Factory がまとめて生成をする。

Factory （インスタンス生成のメソッドが集約されたクラス）は、インターフェースで定義する。複数の Factory が存在し、インターフェースを実装したそれぞれの Factory が関連するオブジェクトをまとめて生成する。

Abstract Factory の内部では、Factory Method が利用されている。

Factory of Factoriesとも呼ばれることもある。

:::note info
使用する Factory は、**クライアントが選択する**
**メソッド**が Factory（一つのメソッドが**複数のオブジェクト**を生成する）
**コンポジション**を利用する
:::

### Abstract Factory の利用例

`Sugar`と`Salt`から構成されるオブジェクト群が存在するとして、
+ `CasualSugar`、`CasualSalt`　というオブジェクト群
+ `LuxuriousSugar`、`LuxuriousSalt`　というオブジェクト群

の2種類があるものとする。

`Casual`と名前がつくオブジェクト群と、`Luxurious`と名前がつくオブジェクト群は、それぞれ別でまとめて生成したい。

このような場合に、メソッド `prepare()` を`CondimentShop`クラスに用意して、**保持(コンポジション)している Factory クラスを利用して、まとめてオブジェクト群の生成が行われる**。
![AbstractFactory.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1069520/1237bd7b-b515-cdb9-7389-a8a23d2a8e18.png)

```java:Sugar.java
// オブジェクト群の構成要素①
public interface Sugar {
    public void description();
}
```

```java:Salt.java
// オブジェクト群の構成要素②
public interface Salt {
    public void description();
}
```

```java:CasualSugar.java
// オブジェクト群の構成要素①
public class CasualSugar implements Sugar {
    public void description() {
        System.out.println("普通の砂糖です。");
    }
}
```

```java:CasualSalt.java
// オブジェクト群の構成要素②
public class CasualSalt implements Salt {
    @Override
    public void description() {
        System.out.println("普通の塩です。");
    }
}
```

```java:LuxuriousSugar.java
// オブジェクト群の構成要素①
public class LuxuriousSugar implements Sugar {
    public void description() {
        System.out.println("高級な砂糖です。");
    }
}
```

```java:LuxuriousSalt.java
// オブジェクト群の構成要素②
public class LuxuriousSalt implements Salt {
    public void description() {
        System.out.println("高級な塩です。");
    }
}
```

```java:CondimentFactory.java
// Factory インターフェース
public interface CondimentFactory {
    public Salt createSalt();
    public Sugar createSugar();
}
```

```java:.java
// オブジェクト群①を生成するための Factory
public class CasualCondimentFactory implements CondimentFactory {
    @Override
    public Salt createSalt() {
        return new CasualSalt();
    }

    @Override
    public Sugar createSugar() {
        return new CasualSugar();
    }
}
```

```java:.java
// オブジェクト群②を生成するための Factory
public class LuxuriousCondimentFactory implements CondimentFactory {
    @Override
    public Salt createSalt() {
        return new LuxuriousSalt();
    }

    @Override
    public Sugar createSugar() {
        return new LuxuriousSugar();
    }
}
```

```java:.java
// Factory を保持するクラス
public class CondimentShop {

    CondimentFactory factory; // Factory が保持されている
    Sugar sugar;
    Salt salt;

    public CondimentShop(CondimentFactory factory) {
        this.factory = factory;
    }

    // オブジェクト群を生成するためのメソッド
    public void prepare() {
        sugar = factory.createSugar();
        salt = factory.createSalt();
    }

    public void description() {
        sugar.description();
        salt.description();
    }
}
```

```java:Main.java
// クライアント
public class Main {
    public static void main(String[] args) {
        // クライアントは Factory を選択するが、Salt、Sugarの具象クラスについては何も知らない（依存関係がない）
        CondimentFactory casualFactory = new CasualCondimentFactory();
        CondimentShop casualShop = new CondimentShop(casualFactory);
        casualShop.prepare(); // 具象クラスのオブジェクト群を生成するメソッド（new が登場しない = 具象クラスに依存しない）
        casualShop.description();
        // >>普通の砂糖です。
        // >>普通の塩です。

        // クライアントは Factory を選択するが、Salt、Sugarの具象クラスについては何も知らない（依存関係がない）
        CondimentFactory luxuriousFactory = new LuxuriousCondimentFactory();
        CondimentShop luxuriousShop = new CondimentShop(luxuriousFactory);
        luxuriousShop.prepare(); // 具象クラスのオブジェクト群を生成するメソッド（new が登場しない = 具象クラスに依存しない）
        luxuriousShop.description();
        // >>高級な砂糖です。
        // >>高級な塩です。
    }
}
```

# 参考
・<a href="https://amzn.asia/d/8MCJXIB" target="_blank" rel="noopener noreferrer">Head Firstデザインパターン ―頭とからだで覚えるデザインパターンの基本</a>