工厂模式-抽象工厂模式

抽象工厂模式

【特点】

• 定义了一个interface用于创建相关或有依赖关系的对象簇，无需指明具体的类
• 当抽象工厂中只存在一个产品体系时将自动退化为普通工厂模式
• 工厂模式本身也是违反OCP原则（工厂修改产品体系时）

【Pizza抽象类】

【BJCheesePizza】

【BJPepperPizza】

【LDCheesePizza】

【LDPepperPizza】

【Mask抽象类】

public abstract class Mask {
    protected String name;
    //抽象风格方法  不同口罩风格由具体不同口罩实现
    public abstract void style();

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

【KN90Mask】

public class KN90Mask extends Mask{
    @Override
    public void style() {
        System.out.println("KN90口罩 风格：时尚");
    }
}

【N95Mask】

public class N95Mask extends Mask{
    @Override
    public void style() {
        System.out.println("N95口罩 风格：防毒");
    }
}

【AbsFactory接口】

//该总工厂负责生成pizza和mask两种产品体系
public interface AbsFactory {

    //pizza产品体系--对应的工厂可能会有多种类型的pizza(需要传参)
    Pizza createPizza(String orderType);
    //mask产品体系--对应的工厂只会生产一种类型的mask口罩
    Mask creatMask();
}

【BJFactory】

public class BJFactory implements AbsFactory{
    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza =null;
        if ("cheese".equals(orderType)){
            pizza = new BJCheesePizza();
            pizza.setName("BJ 奶酪披萨");
        }else if ("pepper".equals(orderType)){
            pizza = new BJPepperPizza();
            pizza.setName("BJ 胡椒披萨");
        }
        return pizza;
    }

    @Override
    public Mask creatMask() {
        //北京工厂只生产 KN90口罩
        return new KN90Mask();
    }
}

【LDFactory】

public class LDFactory implements AbsFactory{
    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if ("cheese".equals(orderType)){
            pizza = new LDCheesePizza();
            pizza.setName("LD 奶酪披萨");
        }else if ("pepper".equals(orderType)) {
            pizza = new LDPepperPizza();
            pizza.setName("LD 胡椒披萨");
        }
        return pizza;
    }

    @Override
    public Mask creatMask() {
        //伦敦工厂只生产 N95口罩
        return new N95Mask();
    }
}

【OrderPizza】

public class OrderPizza {
    AbsFactory absFactory;

    public OrderPizza(AbsFactory absFactory){
        Pizza pizza = null;
        Mask mask = null;
        String orderType = "";
        this.absFactory = absFactory;

        do {
            orderType = getType();
            //此时的pizza可以是北京的工厂，也可以是伦敦的工厂
            pizza = absFactory.createPizza(orderType);
            mask = absFactory.creatMask();
            if (pizza != null){
                //各工厂的生产pizza过程
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
                //各工厂生产mask过程
                mask.style();
            }else {
                System.out.println("订购失败");
                break;
            }
        }while (true);
    }

    //获取用户希望订购的pizza种类
    private String getType(){
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            return bufferedReader.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

【PizzaStore】

// pizza订购客户端 负责发起订购
public class PizzaStore {
    public static void main(String[] args) {
        //使用时只需要new出需要使用到的工厂即可

        //new 一个北京口味的工厂
        new OrderPizza(new BJFactory());
        //new 一个伦敦口味的工厂
        new OrderPizza(new LDFactory());
    }
}

【运行结果】

-工厂模式总结-

【意义】

​ 将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系解耦，从而提高项目的扩展和维护性。

• 创建对象实例时，不要直接new类,而是把这个new类的动作放在一个工厂的方法中并返回。有的书上说，变量不要直接持有具体类的引用。
• 不要让类继承具体类，而是继承抽家类或者是实现interface(接口)
• 不要覆盖基类中已经实现的方法。