工厂模式

创立型模式

这种类型的设计模式属于创立型模式，它提供了一种创建对象的最佳形式。

在工厂模式中，咱们在创建对象时不会对客户端裸露创立逻辑，并且是通过应用一个独特的接口来指向新创建的对象。

介绍

用意： 定义一个创建对象的接口，让其子类本人决定实例化哪一个工厂类，工厂模式使其创立过程提早到子类进行。

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

何时应用： 咱们明确地打算不同条件下创立不同实例时。

如何解决： 让其子类实现工厂接口，返回的也是一个形象的产品。

要害代码： 创立过程在其子类执行。

利用实例： 1. 您须要买披萨，能够间接去披萨店买，而不必去管披萨是怎么做进去的，以及这个披萨外面的具体实现。2、Hibernate 换数据库只需换方言和驱动就能够。

具体实现

第一步

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

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 abstract class OrderPizza {

    // 定义一个形象办法，createPizza，让各个工厂子类本人实现
    abstract Pizza createPizza(String orderType);

    // 结构器
    public OrderPizza() {
        Pizza pizza;
        String orderType; // 订购披萨的类型
        do {orderType = getType();
            pizza = createPizza(orderType); // 形象办法，由工厂子类实现
            // 输入 pizza 制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();} 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 LDOrderPizza extends OrderPizza {

    @Override
    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 BJOrderPizza extends OrderPizza {

    @Override
    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 PizzaStore {public static void main(String[] args) {
        String loc = "bj";
        if (loc.equals("bj")) {
            // 创立北京口味的各种 Pizza
            new BJOrderPizza();} else {
            // 创立伦敦口味的各种 Pizza
            new LDOrderPizza();}
    }

}

总结

长处： 1. 一个调用者想创立一个对象，只有晓得其名称就能够了. 2. 扩展性高，如果想减少一个产品，只有扩大一个工厂类就能够。3. 屏蔽产品的具体实现，调用者只关怀产品的接口。

毛病： 每次减少一个产品时，都须要减少一个具体类和对象实现工厂，使得零碎中类的个数成倍增加，在肯定水平上减少了零碎的复杂度，同时也减少了零碎具体类的依赖. 这并不是什么坏事。