设计模式之抽象工厂模式

设计模式之抽象工厂模式

基本介绍

• 抽象工厂模式：定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类。
• 抽象工厂模式将简单工厂模式和工厂方法模式进行整合
• 从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者成为进一步的抽象)
• 将工厂抽象成两层，AbsFactory(抽象工厂)和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和拓展。

模式结构

工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品等4个要素构成。

1. 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。

2. 具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。

3. 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。

4. 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

具体实现

我们用抽象工厂模式来完成之前的披萨项目

1.绘制UML类图

2.编写代码

/**
 * @author gaoteng
 * 将Pizza类做成抽象(抽象产品)
 */
public abstract class Pizza {
    public String getName() {
        return name;
    }

    /**
     * 名字
     */
    protected String name;
    /**
     *准备原材料, 不同的披萨不一样，因此，我们做成抽象方法
     */
    public abstract void prepare();
    /**
     * 烘烤
     */
    public void bake() {
        System.out.println(name + " baking;");
    }

    /**
     * 切片
     */
    public void cut() {
        System.out.println(name + " cutting;");
    }
    /**
     * 打包
     */
    public void box() {
        System.out.println(name + " boxing;");
    }

    public void setName(String name) {
        this.name = name;
    }
}


/**
 * @author gaoteng
 * 一个抽象工厂模式的抽象层(抽象工厂)
 */
public interface AbsFactory {
    /**
     * 让下面的子类去实现具体方法
     * @param orderType 订单类型
     * @return
     */
    Pizza createPizza(String orderType);
}



/**
 * @author gaoteng
 * 具体工厂子类(具体工厂)
 */
public class BJFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("使用的是抽象工厂模式");
        Pizza pizza = null;
        if("cheese".equals(orderType)){
            pizza = new BJCheesePizza();
            pizza.setName("北京奶酪披萨");
        }else if(orderType.equals("pepper")){
            pizza = new BJPepperPizza();
            pizza.setName("北京胡椒披萨");
        }
        return pizza;
    }
}


/**
 * @author gaoteng
 * 具体工厂子类(具体工厂)
 */
public class LDFactory implements AbsFactory {

    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("使用的是抽象工厂模式");
        Pizza pizza =null;
        if(orderType.equals("cheese")){
            pizza = new LDCheesePizza();
            pizza.setName("伦敦奶酪披萨");
        }else if(orderType.equals("pepper")){
            pizza = new LDPepperPizza();
            pizza.setName("伦敦胡椒披萨");
        }
        return null;
    }
}

//具体产品
public class BJCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京的奶酪pizza");
        System.out.println(" 北京的奶酪pizza 准备原材料");
    }
}
public class BJPepperPizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京的胡椒pizza");
        System.out.println(" 北京的胡椒pizza 准备原材料");
    }
}
public class LDCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setName("伦敦的奶酪pizza");
        System.out.println(" 伦敦的奶酪pizza 准备原材料");
    }
}
public class LDPepperPizza extends Pizza {
    @Override
    public void prepare() {
        setName("伦敦的胡椒pizza");
        System.out.println(" 伦敦的胡椒pizza 准备原材料");
    }
}

3.测试

public class TestAbstractFactory {
    public static void main(String[] args) {
        OrderPizza orderPizza = new OrderPizza(new BJFactory());
        Pizza pizza = orderPizza.factory.createPizza("cheese");
        System.out.println(pizza.getName());
    }
}

优缺点

优点：

• 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
• 当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
• 抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

缺点：

• 当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。