工厂模式

创立型模式

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

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

介绍

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

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

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

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

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

利用实例： 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. 屏蔽产品的具体实现，调用者只关怀产品的接口。

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