美文网首页
设计模式之-抽象工厂模式

设计模式之-抽象工厂模式

作者: MengkZhang | 来源:发表于2019-07-22 16:49 被阅读0次

    1. 介绍

    1.1定义

    抽象工厂模式,提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类;具体的工厂负责实现具体的产品实例。

    抽象工厂模式与工厂方法模式最大的区别:抽象工厂中每个工厂可以创建多种类的产品;而工厂方法每个工厂只能创建一类

    1.2 主要作用

    允许使用抽象的接口来创建一组相关产品,而不需要知道或关心实际生产出的具体产品是什么,这样就可以从具体产品中被解耦。

    1.3 解决的问题

    每个工厂只能创建一类产品 即工厂方法模式的缺点

    2. 模式原理

    2.1 UML类图

    2.2 模式组成


    2.3 使用步骤

    步骤1: 创建抽象工厂类,定义具体工厂的公共接口;
    步骤2: 创建抽象产品族类 ,定义抽象产品的公共接口;
    步骤3: 创建抽象产品类 (继承抽象产品族类),定义具体产品的公共接口;
    步骤4: 创建具体产品类(继承抽象产品类) & 定义生产的具体产品;
    步骤5:创建具体工厂类(继承抽象工厂类),定义创建对应具体产品实例的方法;
    步骤6:客户端通过实例化具体的工厂类,并调用其创建不同目标产品的方法创建不同具体产品类的实例

    3. 实例讲解

    3.1实例概况

    • 背景:小成有两间塑料加工厂(A厂仅生产容器类产品;B厂仅生产模具类产品);随着客户需求的变化,A厂所在地的客户需要也模具类产品,B厂所在地的客户也需要容器类产品;
    • 冲突:没有资源(资金+租位)在当地分别开设多一家注塑分厂
    • 解决方案:在原有的两家塑料厂里增设生产需求的功能,即A厂能生产容器+模具产品;B厂间能生产模具+容器产品。

    即抽象工厂模式
    步骤1: 创建抽象产品族类 ,定义具体产品的公共接口;

    /**
     * Created by zhang on 2019/7/22 0022.
     * Desc:  创建抽象产品族类 ,定义具体产品的公共接口;
     */
    
    public abstract class AbstractProduct {
        public abstract void show();
    }
    

    步骤2: 创建抽象工厂类,定义具体工厂的公共接口

    /**
     * Created by zhang on 2019/7/22 0022.
     * Desc: 创建抽象工厂类,定义具体工厂的公共接口
     */
    
    public abstract class Factory {
        public abstract AbstractProduct manufactureContainer();
        public abstract AbstractProduct manufactureModule();
    }
    

    步骤3: 创建抽象产品类 ,定义具体产品的公共接口;

    /**
     * Created by zhang on 2019/7/22 0022.
     * Desc: 容器产品抽象类
     */
    
    public abstract class ContainerProduct extends AbstractProduct {
        @Override
        public abstract void show();
    }
    
    
    /**
     * Created by zhang on 2019/7/22 0022.
     * Desc: 模具产品抽象类
     */
    
    public abstract class ModuleProduct extends AbstractProduct {
        @Override
        public abstract void show();
    }
    

    步骤4: 创建具体产品类(继承抽象产品类), 定义生产的具体产品;

    /**
     * Created by zhang on 2019/7/22 0022.
     * Desc: 创建具体产品类(继承抽象产品类), 定义生产的具体产品;
     */
    
    public class ContainerProductA extends ContainerProduct {
        @Override
        public void show() {
            Log.e("===z","生产了容器A");
        }
    }
    
    /**
     * Created by zhang on 2019/7/22 0022.
     * Desc: 创建具体产品类(继承抽象产品类), 定义生产的具体产品;
     */
    
    public class ContainerProductB extends ContainerProduct {
        @Override
        public void show() {
            Log.e("===z","生产了容器B");
        }
    }
    
    /**
     * Created by zhang on 2019/7/22 0022.
     * Desc:
     */
    
    public class ModuleProductA extends ModuleProduct {
        @Override
        public void show() {
            Log.e("===z","生产了模具A");
        }
    }
    
    /**
     * Created by zhang on 2019/7/22 0022.
     * Desc:
     */
    
    public class ModuleProductB extends ModuleProduct {
        @Override
        public void show() {
            Log.e("===z","生产了模具B");
        }
    }
    

    步骤5:创建具体工厂类(继承抽象工厂类),定义创建对应具体产品实例的方法;

    /**
     * Created by zhang on 2019/7/22 0022.
     * Desc: 创建具体工厂类(继承抽象工厂类) 定义创建对应具体产品实例的方法
     * A厂 - 生产模具+容器产品
     */
    
    public class FactoryA extends Factory {
        @Override
        public AbstractProduct manufactureContainer() {
            return new ContainerProductA();
        }
    
        @Override
        public AbstractProduct manufactureModule() {
            return new ModuleProductA();
        }
    }
    
    /**
     * Created by zhang on 2019/7/22 0022.
     * Desc: 创建具体工厂类(继承抽象工厂类) 定义创建对应具体产品实例的方法
     * B厂 - 生产模具+容器产品
     */
    
    public class FactoryB extends Factory {
        @Override
        public AbstractProduct manufactureContainer() {
            return new ContainerProductB();
        }
    
        @Override
        public AbstractProduct manufactureModule() {
            return new ModuleProductB();
        }
    }
    
    

    步骤6:客户端通过实例化具体的工厂类,并调用其创建不同目标产品的方法创建不同具体产品类的实例

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            FactoryA factoryA = new FactoryA();
            //A厂当地客户需要容器产品A
            factoryA.manufactureContainer().show();
            //A厂当地客户需要模具产品A
            factoryA.manufactureModule().show();
    
            FactoryB factoryB = new FactoryB();
            //B厂当地客户需要容器产品B
            factoryB.manufactureContainer().show();
            //B厂当地客户需要模具产品B
            factoryB.manufactureModule().show();
    
        }
    

    输出结果:


    4. 优点缺点

    优点

    • 降低耦合
    • 更符合开-闭原则
      新增一种产品类时,只需要增加相应的具体产品类和相应的工厂子类即可
    • 符合单一职责原则
      每个具体工厂类只负责创建对应的产品
    • 不使用静态工厂方法,可以形成基于继承的等级结构。

    缺点

    抽象工厂模式很难支持新种类产品的变化。
    这是因为抽象工厂接口中已经确定了可以被创建的产品集合,如果需要添加新产品,此时就必须去修改抽象工厂的接口,这样就涉及到抽象工厂类的以及所有子类的改变,这样也就违背了“开发——封闭”原则

    5. 应用场景

    • 一个系统不要求依赖产品类实例如何被创建、组合和表达的表达,这点也是所有工厂模式应用的前提。
    • 这个系统有多个系列产品,而系统中只消费其中某一系列产品
    • 系统要求提供一个产品类的库,所有产品以同样的接口出现,客户端不需要依赖具体实现。

    OK 抽象工厂模式到此为止 下期 我们讲建造者模式

    相关文章

      网友评论

          本文标题:设计模式之-抽象工厂模式

          本文链接:https://www.haomeiwen.com/subject/rsuwlctx.html