抽象工厂模式

基本介绍

　　1）抽象工厂模式：定义了一个 interface 用于创建相关或有依赖关系的对象簇，而无需指明具体的类

　　2）抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。

　　3）从设计层面看，抽象工厂模式主是对简单工厂模式的改进（或者称为进一步的抽象）。

　　4）将工厂抽象成两层，AbsFactory（抽象工厂）和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

类图

 

代码演示

package com.atguigu.factory.absfactory.pizzastore.pizza;

/**
 * 将披萨类做成抽象类
 */
public abstract class 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;
    }
}

package com.atguigu.factory.absfactory.pizzastore.pizza;

public class BJCheesePizza extends Pizza {

    @Override
    public void prepare() {
        setName("北京奶酪披萨");
        System.out.println("北京奶酪披萨 准备原料");
    }
}

package com.atguigu.factory.absfactory.pizzastore.pizza;

public class BJPepperPizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京胡椒披萨");
        System.out.println("北京胡椒披萨 准备原料");
    }
}

package com.atguigu.factory.absfactory.pizzastore.pizza;

public class LDCheesePizza extends Pizza {

    @Override
    public void prepare() {
        setName("伦敦奶酪披萨");
        System.out.println("伦敦奶酪披萨 准备原料");
    }
}

package com.atguigu.factory.absfactory.pizzastore.pizza;

public class LDPepperPizza extends Pizza {
    @Override
    public void prepare() {
        setName("伦敦胡椒披萨");
        System.out.println("伦敦胡椒披萨 准备原料");
    }
}

AbsFactory 接口中定义一个创建披萨的方法让子类工厂去实现

BJFactory

LDFactory

package com.atguigu.factory.absfactory.pizzastore.order;


import com.atguigu.factory.absfactory.pizzastore.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class OrderPizza {

    AbsFactory factory;

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

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

        do {
            orderType = getType();
            // factory 可能是北京的工厂子类也可能是伦敦的工厂子类
            pizza = factory.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 type:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

package com.atguigu.factory.absfactory.pizzastore.order;

/**
 * 披萨店，测试
 */
public class PizzaStore {
    public static void main(String[] args) {
//        new OrderPizza(new BJFactory());
        new OrderPizza(new LDFactory());
    }
}

工厂模式小结

　　1）工厂模式的意义

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

　　2）三种工厂模式（简单工厂模式、工厂方法模式、抽象工厂模式）

　　3）设计模式的依赖抽象原则

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