2抽象工厂模式

抽象工厂模式

抽象工厂模式(Abstract Factory Pattern)是一种比较常用的模式。

1抽象工厂模式的定义

抽象工厂模式的英文原文是:
Provide an interface for creating families of related or dependent objects without specifying their concrete class.
意思是：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。
抽象工厂模式的角色与工厂模式类似，有4种：

  • 抽象工厂(Abstract)角色:抽象工厂模式的核心，与应用系统无关，任何创建对象的工厂类必须实现这个接口。
  • 具体工厂(Concrete Factory)角色：实现了抽象工厂接口，含有选择合适的产品对象逻辑，并且受到应用程序的调用以创建产品对象。
  • 抽象产品(Abstract Product)角色：负责定义产品的共性，实现对产品最抽象的定义。
  • 具体产品(Concrete Product)角色:该角色实现抽象产品角色所声明的接口，抽象工厂模式创建的任何产品对象都是某个具体产品角色的实例。

2抽象工厂模式的应用


优点
抽象工厂模式是工厂模式的进一步抽象，针对的是一族产品。如果产品族中只有一种产品，则抽象工厂模式就退化为工厂模式。
  • 产品族内的约束为非公开状态，在不同的工厂中，各种产品可能具有不同的相互依赖关系，这些依赖关系由工厂封装在其内部，对于工厂的使用者是不可见的。
  • 生产线的扩展非常容易，如果要针对同一产品族建立新的生产线，只需要实现产品族中的所有产品接口并建立新的工厂类即可。

缺点
抽象工厂模式的最大缺点就是产品族本身的扩展非常困难，如果需要在产品族组中增加一个新的产品类型，则需要修改多个接口，并且会影响已有的工厂类。

使用场景
当一个对象族(或是一组没有任何关系的对象)都有相同的约束，则可以使用抽象工厂模式。
抽象工厂模式是一个简单的模式，使用场景非常多，例如，应用需要涉及不同操作系统的时候，可以考虑抽象工厂模式，如果需要在三个不同的平台(Windows\Linux\Android)上运行，则可以通过抽象工厂模式屏蔽掉操作系统对应用的影响。三个不同的操作系统上的软件功能、应用逻辑、UI都应该是非常类似的。唯一不同的是调用不同的工厂方法，由不同的产品类去处理与操作系统交互的信息。

3抽象工厂的实例
需要创建10个java文件。

步骤1
创建抽象工厂类
AbstarctFactory.java
package com.eric.创建型模式.抽象工厂模式.例1.factory;

import com.eric.创建型模式.抽象工厂模式.例1.product.ProductA;
import com.eric.创建型模式.抽象工厂模式.例1.product.ProductB;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 抽象工厂类
 * @CreateTime 2020-11-25 12:42:38
 */
public interface AbstractFactory {
    //创建产品A
    public ProductA factoryA();
    //创建产品B
    public ProductB factoryB();
}

步骤2
创建工厂实现类
concreteFactory1.java
import com.eric.创建型模式.抽象工厂模式.例1.product.ProductB;
import com.eric.创建型模式.抽象工厂模式.例1.product.ProductB1;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 一等工厂
 * @CreateTime 2020-11-25 12:49:06
 */
public class ConcreteFactory1 implements AbstractFactory{
    //创建等级为1的A产品
    @Override
    public ProductA factoryA() {
        return new ProductA1();
    }

    //创建等级为1的B产品
    @Override
    public ProductB factoryB() {
        return new ProductB1();
    }
}
concreteFactory2.java
package com.eric.创建型模式.抽象工厂模式.例1.factory;

import com.eric.创建型模式.抽象工厂模式.例1.product.ProductA;
import com.eric.创建型模式.抽象工厂模式.例1.product.ProductA2;
import com.eric.创建型模式.抽象工厂模式.例1.product.ProductB;
import com.eric.创建型模式.抽象工厂模式.例1.product.ProductB2;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 二等工厂
 * @CreateTime 2020-11-25 12:53:48
 */
public class ConcreteFactory2 implements AbstractFactory{
    //等级为2的A产品
    @Override
    public ProductA factoryA() {
        return new ProductA2();
    }
    //等级为2的B产品
    @Override
    public ProductB factoryB() {
        return new ProductB2();
    }
}

步骤3
创建产品的接口ProductA.java、ProductB.java以及实现类

产品A的接口： 
ProductA.java
package com.eric.创建型模式.抽象工厂模式.例1.product;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 产品A的公共方法
 * @CreateTime 2020-11-25 12:44:59
 */
public interface ProductA {
    //产品A的公共方法
    public void method1();
    public void method2();
}
ProductA1.java
package com.eric.创建型模式.抽象工厂模式.例1.product;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 等级为1的A产品
 * @CreateTime 2020-11-25 12:50:41
 */
public class ProductA1 implements ProductA {
    @Override
    public void method1() {
        System.out.println("等级1的产品A生产中...");
    }

    @Override
    public void method2() {
        System.out.println("等级1的产品A销毁中...");
    }
}
ProductA2.java
package com.eric.创建型模式.抽象工厂模式.例1.product;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 等级为2的A产品
 * @CreateTime 2020-11-25 12:51:11
 */
public class ProductA2 implements ProductA{
    @Override
    public void method1() {
        System.out.println("等级2的产品A生产中...");
    }

    @Override
    public void method2() {
        System.out.println("等级2的产品A销毁中...");
    }
}

产品B的接口：
ProductB.java
package com.eric.创建型模式.抽象工厂模式.例1.product;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 产品B的抽象类
 * @CreateTime 2020-11-25 12:46:06
 */
public interface ProductB {
    //产品B的公共方法
    public void method1();
    public void method2();
}
ProductB1.java
package com.eric.创建型模式.抽象工厂模式.例1.product;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 等级为1的B产品
 * @CreateTime 2020-11-25 12:51:29
 */
public class ProductB1 implements ProductB {
    @Override
    public void method1() {
        System.out.println("等级1的产品B生产中...");
    }

    @Override
    public void method2() {
        System.out.println("等级1的产品B销毁中...");
    }
}
ProductB2.java
package com.eric.创建型模式.抽象工厂模式.例1.product;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 等级为2的B产品
 * @CreateTime 2020-11-25 12:51:46
 */
public class ProductB2 implements ProductB {
    @Override
    public void method1() {
        System.out.println("等级2的产品B生产中...");
    }

    @Override
    public void method2() {
        System.out.println("等级2的产品B销毁中...");
    }
}

步骤4
创建测试类
ClientDemo.java
package com.eric.创建型模式.抽象工厂模式.例1;

import com.eric.创建型模式.抽象工厂模式.例1.factory.AbstractFactory;
import com.eric.创建型模式.抽象工厂模式.例1.factory.ConcreteFactory1;
import com.eric.创建型模式.抽象工厂模式.例1.factory.ConcreteFactory2;
import com.eric.创建型模式.抽象工厂模式.例1.product.ProductA1;
import com.eric.创建型模式.抽象工厂模式.例1.product.ProductA2;
import com.eric.创建型模式.抽象工厂模式.例1.product.ProductB1;
import com.eric.创建型模式.抽象工厂模式.例1.product.ProductB2;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 客户端测试
 * @CreateTime 2020-11-25 12:58:39
 */
public class ClientDemo {
    public static void main(String[] args) {
        //定义两个工厂
        AbstractFactory concreteFactory1 = new ConcreteFactory1();
        AbstractFactory concreteFactory2 = new ConcreteFactory2();

        //生产等级为1的产品A
        ProductA1 productA1 = new ProductA1();
        //生产等级为2的产品A
        ProductA2 productA2 = new ProductA2();
        //生产等级为1的产品B
        ProductB1 productB1 = new ProductB1();
        //生产等级为2的产品B
        ProductB2 productB2 = new ProductB2();

        //业务处理
        productA1.method1();
        productA2.method1();
        productB1.method1();
        productB2.method1()

    }
}
测试结果：





posted @ 2020-11-25 20:22  喵酱张-Eric  阅读(66)  评论(0)  编辑  收藏  举报