形象工厂模式

创立型模式

形象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创立其余工厂。该超级工厂又称为其余工厂的工厂。这种类型的设计模式属于创立型模式，它提供了一种创建对象的最佳形式。

在形象工厂模式中，接口是负责创立一个相干对象的工厂，不须要显式指定它们的类。每个生成的工厂都能依照工厂模式提供对象。

介绍

用意： 提供一个创立一系列相干或相互依赖对象的接口，而无需指定它们具体的类。

次要解决： 次要解决接口抉择的问题。

何时应用： 零碎的产品有多于一个的产品族，而零碎只生产其中某一族的产品。

如何解决： 在一个产品族外面，定义多个产品。

要害代码： 在一个工厂里聚合多个同类产品。

利用实例： 当须要创立的对象是一系列互相关联或相互依赖的产品族时，便能够应用形象工厂模式。说的更明确一点，就是一个继承体系中，如果存在着多个等级构造（即存在着多个抽象类），并且分属各个等级构造中的实现类之间存在着肯定的关联或者束缚，就能够应用形象工厂模式。如果各个等级构造中的实现类之间不存在关联或束缚，则应用多个独立的工厂来对产品进行创立，则更适合一点。

具体实现

第一步

创立披萨的制作步骤的抽象类

public abstract class Pizza {

    //pizza 的名字
    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;}
}

第二步

继承披萨的抽象类, 制作不同的披萨

public class BJCheesePizza extends Pizza {

    @Override
    public void prepare() {setName("北京奶酪 pizza");
        System.out.println(name + "筹备原材料");
    }
}

public class BJPepperPizza extends Pizza {

    @Override
    public void prepare() {setName("北京胡椒 pizza");
        System.out.println(name + "筹备原材料");
    }
}

public class LDCheesePizza extends Pizza {

    @Override
    public void prepare() {setName("伦敦奶酪 pizza");
        System.out.println(name + "筹备原材料");
    }
}

public class LDPepperPizza extends Pizza {

    @Override
    public void prepare() {setName("伦敦胡椒 pizza");
        System.out.println(name + "筹备原材料");
    }
}

第三步

创立一个形象工厂接口

public interface AbsFactory {

    // 让上面的工厂子类来具体实现
    Pizza createPizza(String orderType);
}

public class BJFactory implements AbsFactory {

    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")) {pizza = new BJPepperPizza();
        }
        return pizza;
    }
}

public class LDFactory implements AbsFactory {

    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {pizza = new LDCheesePizza();
        } else if (orderType.equals("pepper")) {pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

第四步

创立一个工厂的生成器类

public class OrderPizza {

    AbsFactory absFactory;

    public OrderPizza(AbsFactory absFactory) {setAbsFactory(absFactory);
    }

    private void setAbsFactory(AbsFactory absFactory) {
        Pizza pizza = null;
        String orderType = "";// 用户输出
        this.absFactory = absFactory;

        do {orderType = getType();
            pizza = absFactory.createPizza(orderType);
            if (pizza != null) {pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();} else {System.out.println("订购失败");
                break;
            }
        } while (true);
    }

    // 写一个办法，能够获取客户心愿订购的披萨品种
    private String getType() {
        try {BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 品种:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {e.printStackTrace();
            return "";
        }
    }

}

第五步

创立测试类

public class PizzaStore {public static void main(String[] args) {//new OrderPizza(new BJFactory());
        new OrderPizza(new LDFactory());
    }
}

总结

长处： 当一个产品族中的多个对象被设计成一起工作时，它能保障客户端始终只应用同一个产品族中的对象。

毛病： 产品族扩大十分艰难，要减少一个系列的某一产品，既要在形象的 Pizza 里退出子类，又要在形象工厂中退出实现类。