概要概要

ファクトリパターン（~~シンプルファクトリパターン~~、ファクトリメソッドパターン、抽象ファクトリパターン）は、23のデザインパターンの中で最も一般的に使用されるものであり、デザインパターンの作成パターンに属します。
ファクトリパターンは、Javaインターフェイス指向のプログラミングの現れです。オブジェクトを作成するとき、作成ロジックをクライアントに公開しませんが、抽象的なインターフェイスを介してオブジェクトを作成し、使用と作成を分離し、結合を減らし、拡張を容易にします。
jdbc、spring ioc、spring aop、parsing xml、Executorsなど、ファクトリモデルには多くのアプリケーションシナリオがあります。実際の開発では、さまざまな形式のレポートのエクスポート、さまざまなハードウェアメーカーの一部のインターフェイスのドッキングなど、無数にあります。

シンプルなファクトリーパターン

ここに写真の説明を挿入

/**
 * 手机（抽象产品角色）
 */
public interface Phone {
    
    

    //获取手机
    void getPhone();
}

/**
 * @date 2020/5/9 19:55
 * @Author yz
 * 华为手机实现类（具体产品角色）
 */
public class HuaweiPhone implements Phone{
    
    
    @Override
    public void getPhone() {
    
    
        System.out.println("华为手机");
    }
}

/**
 * @date 2020/5/9 19:54
 * @Author yz
 * 小米手机实现类（具体产品角色）
 */
public class XiaomiPhone implements Phone{
    
    
    @Override
    public void getPhone() {
    
    
        System.out.println("小米手机");
    }
}

/**
 * @date 2020/5/9 19:56
 * @Author yz
 * 手机工厂类（工厂角色）
 */
public class PhoneFactory {
    
    

    /**
     * 生产手机
     */
    public Phone producePhone(String name){
    
    
        Phone phone=null;
        if("xiaomi".equals(name))
            phone=new XiaomiPhone();
        if("huawei".equals(name))
            phone=new HuaweiPhone();
        return phone;
    }
}

public class Customer {
    
    

    public static void main(String[] args) {
    
    
        PhoneFactory phoneFactory=new PhoneFactory();
        Phone xiaomi = phoneFactory.producePhone("xiaomi");
        Phone huawei = phoneFactory.producePhone("huawei");
        xiaomi.getPhone();
        huawei.getPhone();
    }
}

組成

工場の役割（PhoneFactory）
抽象製品の役割（電話）
複数の特定の製品の役割（HuaweiPhone、XiaomiPhone）

応用

ビジネスは比較的単純で、実装クラスが少なくなっています
固定ビジネス、基本的に変更する必要はありません
呼び出し元は実装ロジックを気にする必要はありません

利点

実装を保護するため、呼び出し元は特定の実装、適切なカプセル化、デカップリングを気にする必要がなく、ビジネスの拡大に便利です。新しい実装が必要な場合は、実装クラスを追加してファクトリクラスを変更するだけで済みます。

不利益

実装クラスを追加するたびに、ファクトリクラスを変更する必要があります。これは、開閉の原則に違反します。実装クラスが多すぎると、保守が容易でなく、ファクトリクラスが肥大化します。

ファクトリーメソッドパターン

ここに写真の説明を挿入

/**
 * 手机（抽象产品角色）
 */
public interface Phone {
    
    

    //得到手机
    void getPhone();
}

/**
 * @date 2020/5/9 19:54
 * @Author yz
 * 小米手机实现类（具体产品角色）
 */
public class XiaomiPhone implements Phone {
    
    
    @Override
    public void getPhone() {
    
    
        System.out.println("小米手机");
    }
}

/**
 * @date 2020/5/9 19:55
 * @Author yz
 * 华为手机实现类（具体产品角色）
 */
public class HuaweiPhone implements Phone {
    
    
    @Override
    public void getPhone() {
    
    
        System.out.println("华为手机");
    }
}

/**
 * @date 2020/5/9 19:56
 * @Author yz
 * 手机工厂类（抽象工厂）
 */
public interface PhoneFactory {
    
    
    /**
     * 生产手机
     */
    public Phone producePhone();
}

/**
 * @date 2020/5/9 19:54
 * @Author yz
 * 小米手机工厂类（实例工厂）
 */
public class XiaomiPhoneFactory implements PhoneFactory {
    
    

    @Override
    public Phone producePhone() {
    
    
        return new XiaomiPhone();
    }
}

/**
 * @date 2020/5/16 11:27
 * @Author yz
 * 华为手机工厂类（实例工厂）
 */
public class HuaweiPhoneFactory implements PhoneFactory {
    
    

    @Override
    public Phone producePhone() {
    
    
        return new HuaweiPhone();
    }
}

/**
 * @date 2020/5/9 19:59
 * @Author yz
 * 客户类
 */
public class Customer {
    
    

    public static void main(String[] args) {
    
    
        PhoneFactory xiaomiPhoneFactory=new XiaomiPhoneFactory();
        PhoneFactory huaweiPhoneFactory=new HuaweiPhoneFactory();
        xiaomiPhoneFactory.producePhone().getPhone();
        huaweiPhoneFactory.producePhone().getPhone();
    }
}

組成

抽象ファクトリロール（PhoneFactory）
抽象製品の役割（電話）
複数の特定の製品の役割（HuaweiPhone、XiaomiPhone）
複数の特定のファクトリロール（HuaweiPhoneFactory、XiaomiPhoneFactory）

利点

新しい実装を追加する場合、コードを変更する必要はなく、新しい製品と工場を追加するだけで、開閉の原則に違反する単純な工場の欠点を解決できます。

不利益

製品（インスタンスクラス）を追加するたびに、ファクトリクラスを追加する必要があります。これにより、ファクトリクラスの数が簡単に増え、管理が難しくなります。

抽象工場法

ここに写真の説明を挿入

/**
 * 手机（抽象产品角色）
 */
public interface Phone {
    
    

    //生产
    void getPhone();
}

/**
 * @date 2020/5/9 19:54
 * @Author yz
 * 小米手机实现类（具体产品角色）
 */
public class XiaomiPhone implements Phone {
    
    
    @Override
    public void getPhone() {
    
    
        System.out.println("小米手机");
    }
}

/**
 * @date 2020/5/9 19:55
 * @Author yz
 * 华为手机实现类（具体产品角色）
 */
public class HuaweiPhone implements Phone {
    
    
    @Override
    public void getPhone() {
    
    
        System.out.println("华为手机");
    }
}

/**
 * 充电器（抽象产品角色）
 */
public interface Charger {
    
    

    //得到充电器
    void getCharger();
}

/**
 * @date 2020/5/31 16:17
 * @Author yz
 * 小米充电器实现类（具体产品角色）
 */
public class XiaomiCharger implements Charger{
    
    
    @Override
    public void getCharger() {
    
    
        System.out.println("小米充电器");
    }
}

/**
 * @date 2020/5/31 16:17
 * @Author yz
 * 华为充电器实现类（具体产品角色）
 */
public class HuaweiCharger implements Charger{
    
    
    @Override
    public void getCharger() {
    
    
        System.out.println("华为充电器");
    }
}

/**
 * @date 2020/5/9 19:56
 * @Author yz
 * 电子产品工厂类（抽象工厂）
 */
public interface ElectronicFactory {
    
    
    /**
     * 得到手机
     */
    public Phone producePhone();

    /**
     * 得到充电器
     */
    public Charger produceCharger();
}

/**
 * @date 2020/5/9 19:54
 * @Author yz
 * 小米工厂类（实例工厂）
 */
public class XiaomiFactory implements ElectronicFactory {
    
    

    @Override
    public Phone producePhone() {
    
    
        return new XiaomiPhone();
    }

    @Override
    public Charger produceCharger() {
    
    
        return new XiaomiCharger();
    }
}

/**
 * @date 2020/5/16 11:27
 * @Author yz
 * 华为工厂类（实例工厂）
 */
public class HuaweiFactory implements ElectronicFactory {
    
    

    @Override
    public Phone producePhone() {
    
    
        return new HuaweiPhone();
    }

    @Override
    public Charger produceCharger() {
    
    
         return new HuaweiCharger();
    }
}

public class Customer {
    
    

    public static void main(String[] args) {
    
    
        ElectronicFactory xiaomiPhoneFactory=new XiaomiFactory();
        ElectronicFactory huaweiPhoneFactory=new HuaweiFactory();
        xiaomiPhoneFactory.producePhone().getPhone();
        huaweiPhoneFactory.producePhone().getPhone();
        xiaomiPhoneFactory.produceCharger().getCharger();
        huaweiPhoneFactory.produceCharger().getCharger();
    }
}

組成

抽象ファクトリの役割（ElectronicFactory）
複数の抽象的な製品の役割（電話、充電器）
複数の特定の製品の役割（HuaweiPhone、XiaomiPhone、HuaweiCharger、XiaomiCharger）
複数の特定のファクトリロール（HuaweiFactory、XiaomiFactory）

利点

開閉の原理に準拠しており、製品ファミリーを簡単に増やすことができ、対応する製品や工場を増やすだけで、高いスケーラビリティを実現します。

不利益

製品を追加する必要がある場合は、ファクトリクラス（抽象ファクトリ、インスタンスファクトリ）のすべてのメソッドを変更する必要があります。これは、開閉の原則に違反します。

抽象ファクトリー方式とファクトリー方式の違い

工場メソッドパターン：抽象製品クラスは、複数の具体的な製品クラスを導出できます。抽象ファクトリクラスは、複数の具体的なファクトリクラスを派生させることができます。各コンクリートファクトリクラスは、コンクリート製品クラスのインスタンスを1つだけ作成できます。

抽象ファクトリパターン：複数の抽象製品カテゴリ。各抽象製品カテゴリは、複数の特定の製品カテゴリを導出できます。抽象ファクトリクラスは、複数の具体的なファクトリクラスを派生させることができます。特定のファクトリクラスごとに、特定の製品クラスの複数のインスタンスを作成できます。

違い：ファクトリメソッドパターンには1つの抽象製品クラスしかありませんが、抽象ファクトリパターンには複数あります。ファクトリメソッドパターンの具象ファクトリクラスは、具象製品クラスの1つのインスタンスしか作成できませんが、抽象ファクトリパターンは複数のインスタンスを作成できます。

総括する

3つの方法には長所と短所があります。抽象的な工場の複雑な構造と拡大されたビュー>工場の方法>単純なプラント、実際の開発から、それは最も単純な工場、工場の方法で使用され、より抽象的な工場、工場を使用しますメソッドと抽象ファクトリはシステムのスケーラビリティを向上させますが、単純なファクトリよりも変更が面倒です。本物のマスターには勝つためのトリックがありません。武道のマスターはトリックに100％従うことはできません。ビジネスと組み合わせて使用してください。最高のものが最高です。

Javaデザインパターンのファクトリーパターンの説明

概要概要

シンプルなファクトリーパターン

組成

応用

利点

不利益

ファクトリーメソッドパターン

組成

利点

不利益

抽象工場法

組成

利点

不利益

抽象ファクトリー方式とファクトリー方式の違い

総括する

おすすめ