工厂模式

工厂模式的意义是将实例化对象的过程提取出来，放到一个类中进行统一管理和维护，从而实现与主业务的解耦，提高扩展性和维护性。

目前存在三种工厂模式（简单工厂模式、工厂方法模式、抽象工厂模式）

基于一个场景，进行介绍。

场景需求要点如下：

• 披萨有许多品种。
• 披萨的制作流程中，不同的种类有不一样的地方。例如准备、烘烤、切块、打包等。
• 实现披萨订购功能

传统的方法：

（1）首先创建一个披萨的父类，不同种类的披萨继承与这个披萨父类

（2）订购披萨类，订购时进行披萨类型判断，按照类型创建相应的披萨类，然后进行准备、烘烤、切块、打包等处理。

简单工厂模式：

则是将披萨类的创建过程，抽象封装成工厂类，专门处理披萨类的创建。

工厂模式：

当需求进一步添加，新增加不同的区域进行扩充披萨的种类。

则是在订购类中创建抽象方法，有不同区域的工厂类去实现。

抽象工厂模式：

将工厂模式的订购类中抽象方法，抽取出来定义为接口（抽象工厂），其它工厂类（具体工厂）去实现接口。

传统方法

实例化披萨类过程与订购业务耦合在一起，但出现的新的披萨类，则需要修改订购业务代码。

public class OrderPizza {
    public OrderPizza() {
        Pizza pizza = null;
        String orderType; // 订购披萨的类型
        do {
            orderType = getType();
            if (orderType.equals("greek")) {
                pizza = new GreekPizza();
                pizza.setName(" 希腊披萨 ");
            } else if (orderType.equals("cheese")) {
                pizza = new CheesePizza();
                pizza.setName(" 奶酪披萨 ");
            } else if (orderType.equals("pepper")) {
                pizza = new PepperPizza();
                pizza.setName("胡椒披萨");
            } else {
                break;
            }
            //输出pizza 制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
​
        } while (true);
    }
}

简单工厂模式

将披萨类的实例化过程抽取封装成统一的工厂类

public class OrderPizza {
​
    Pizza pizza = null;
    String orderType = "";
    // 构造器
    public OrderPizza() {
        
        do {
            orderType = getType();
            pizza = SimpleFactory.createPizza2(orderType);
            // 输出pizza
            if (pizza != null) { // 订购成功
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println(" 订购披萨失败 ");
                break;
            }
        } while (true);
    }
}
//简单工厂类
public class SimpleFactory {
    
    //简单工厂模式 也叫 静态工厂模式 
    
    public static Pizza createPizza2(String orderType) {
​
        Pizza pizza = null;
​
        System.out.println("使用简单工厂模式2");
        if (orderType.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName(" 希腊披萨 ");
        } else if (orderType.equals("cheese")) {
            pizza = new CheesePizza();
            pizza.setName(" 奶酪披萨 ");
        } else if (orderType.equals("pepper")) {
            pizza = new PepperPizza();
            pizza.setName("胡椒披萨");
        }
        
        return pizza;
    }
​
}
​

工厂方法模式

将订购类和工厂类的依赖倒转，更有利于工厂类扩展

public abstract class OrderPizza {
​
    //定义一个抽象方法，createPizza , 让各个工厂子类自己实现
    abstract Pizza createPizza(String orderType);
    
    // 构造器
    public OrderPizza() {
        Pizza pizza = null;
        String orderType; // 订购披萨的类型
        do {
            orderType = getType();
            pizza = createPizza(orderType); //抽象方法，由工厂子类完成
            //输出pizza 制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
            
        } while (true);
    }
​
}
// 实现抽象方法
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();
        }
        // TODO Auto-generated method stub
        return pizza;
    }
}
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();
        }
        // TODO Auto-generated method stub
        return pizza;
    }
​
}

抽象工厂模式

将工厂模式的订购类中抽象方法，抽取出来定义为接口（抽象工厂），其它工厂类（具体工厂）去实现接口。

public class OrderPizza {
​
    AbsFactory factory;
​
    // 构造器
    public OrderPizza(AbsFactory factory) {
        setFactory(factory);
    }
​
    private void setFactory(AbsFactory factory) {
        Pizza pizza = null;
        String orderType = ""; // 用户输入
        this.factory = factory;
        do {
            orderType = getType();
            // factory 可能是北京的工厂子类，也可能是伦敦的工厂子类
            pizza = factory.createPizza(orderType);
            if (pizza != null) { // 订购ok
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("订购失败");
                break;
            }
        } while (true);
    }
}
//一个抽象工厂模式的抽象层(接口)
public interface AbsFactory {
    //让下面的工厂子类来 具体实现
    public Pizza createPizza(String orderType);
}
//这是工厂子类
public class BJFactory implements AbsFactory {
​
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("~使用的是抽象工厂模式~");
        // TODO Auto-generated method stub
        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) {
        System.out.println("~使用的是抽象工厂模式~");
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new LDCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
​
}