Java设计模式：工厂设计模式简单工厂模式基本介绍1)简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一

简单工厂模式

基本介绍

1) 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式；

2) 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)；

3) 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。

一个简单的需求

一个披萨的项目：要便于披萨种类的扩展，要便于维护

1) 披萨的种类很多(比如 GreekPizz、CheesePizz 等)；

2) 披萨的制作有 prepare，bake, cut, box；

3) 完成披萨店订购功能。

传统的方式

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 CheesePizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("为CheesePizza准备原材料");
    }
}

public class GreekPizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("为GreekPizza准备原材料");
    }
}

public class OrderPizza {//根据用户的输入创建对象
    public OrderPizza(){
        Pizza pizza = null;
        String orderType;
        do {
            orderType = getType();
            if (orderType.equals("greek")){
                pizza = new GreekPizza();
                pizza.name = "希腊披萨";
            }else if (orderType.equals("cheese")){
                pizza = new CheesePizza();
                pizza.name = "奶酪披萨";
            }else {
                System.out.println("--退出程序--");
                break;
            }
            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 PizzaStore {//相当于一个客户端，发出订单
    public static void main(String[] args) {
        OrderPizza orderPizza = new OrderPizza();
    }
}

传统的方式的优缺点

1) 优点是比较好理解，简单易操作；

2) 缺点是违反了设计模式的ocp原则，即对扩展开放，对修改关闭。即当我们给类增

加新功能的时候，尽量不修改代码，或者尽可能少修改代码。

**分析**：修改代码可以接受，但是如果我们在其它的地方也有创建Pizza的代码，就意味着，也需要修改，而创建Pizza的代码，往往有多处。

**思路**：把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类时，只需要修改该类就可，其它有创建到Pizza对象的代码就不需要修改了。

使用简单工厂模式

简单工厂模式的设计方案: 定义一个可以实例化Pizaa对象的类，封装创建对象的代码。
代码演示：

public class SimplePizzaFactory {//编写简单工厂 public Pizza createPizza(String type) { Pizza pizza = null; if (type.equals("cheese")) { pizza = new CheesePizza(); pizza.name = "奶酪披萨"; } else if (type.equals("greek")) { pizza = new GreekPizza(); pizza.name = "希腊披萨"; } return pizza; } }

public class OrderPizza {//重新编写OrderPizza类，其他类不变
//    定义一个简单工厂对象
    SimplePizzaFactory simplePizzaFactory;
//    构造器
    public OrderPizza(SimplePizzaFactory simplePizzaFactory){
        setFactory(simplePizzaFactory);
    }
    public void setFactory(SimplePizzaFactory simplePizzaFactory) {
        String orderType;//用户输入的披萨类型
        Pizza pizza = null;
        this.simplePizzaFactory = simplePizzaFactory;//设置简单工厂对象
        do {
            orderType = getType();
            pizza = this.simplePizzaFactory.createPizza(orderType);
            if (pizza != null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else {
                break;
            }
        }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 "";
        }
    }
}

工厂方法模式

工厂方法模式介绍

定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

一个新的需求

披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪pizza、

北京的胡椒pizza 或者是伦敦的奶酪pizza、伦敦的胡椒pizza。

**工厂方法模式设计方案：**将披萨项目的实例化功能抽象成抽象方法，在不同的口味点

餐子类中具体实现。

使用工厂方法模式

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 class BJCheesePizza extends Pizza {
    @Override
    public void prepare() {
        name = "北京奶酪 Pizza";
        System.out.println("北京奶酪Pizza 准备材料~~~~");
    }
}

public class BJPepperPizza extends Pizza{
    @Override
    public void prepare() {
        name = "北京胡椒 Pizza";
        System.out.println("北京胡椒Pizza 准备材料~~~~");
    }
}

public class LDCheesePizza extends Pizza {
    @Override
    public void prepare() {
        name = "伦敦奶酪 Pizza";
        System.out.println("伦敦奶酪Pizza 准备材料~~~~");
    }
}

public class LDPepperPizza extends Pizza {
    @Override
    public void prepare() {
        name = "伦敦胡椒 Pizza";
        System.out.println("伦敦胡椒Pizza 准备材料~~~~");
    }
}

public abstract class OrderPizza {

//    定义一个抽象方法createPizza，让各个工厂子类自己实现
    abstract Pizza createPizza(String orderType);

//    构造器    
public OrderPizza(){
        String orderType;//用户输入的披萨类型
        Pizza pizza = null;
        do {
            orderType = getType();
            pizza = createPizza(orderType);
//            输出pizza制作过程
            if (pizza != null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else {
                break;
            }
        }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 BJOrderPizza extends OrderPizza {//继承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 LDOrderPizza extends OrderPizza {//继承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 PizzaStore {//相当于一个客户端，发出订单
    public static void main(String[] args) {
        new BJOrderPizza();
        System.out.println("--退出程序--");
    }
}

抽象工厂模式

基本介绍

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

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

3) 从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)；

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

使用抽象工厂模式

Pizza及其继承类BJCheesePizza、BJPepperPizza、LDCheesePizza、LDPepperPizza不变

//一个抽象工厂模式的抽象层（接口）
public interface AbsFactory {
//    让下面的工厂子类去具体实现
    public Pizza createPizza(String orderType);
}

//这是一个工厂子类
public class BJFactory implements AbsFactory {
    @Override
    public 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 LDFactory implements AbsFactory{
    @Override
    public 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 OrderPizza {
    AbsFactory factory;
    OrderPizza(AbsFactory factory) {
        setFactory(factory);
    }
    private void setFactory(AbsFactory factory){
        Pizza pizza = null;
        String orderType = "";//用户输入
        this.factory = factory;
        do {
            orderType = getType();
            pizza = factory.createPizza(orderType);
//            输出pizza制作过程
            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 种类:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

public class PizzaStore {//相当于一个客户端，发出订单
    public static void main(String[] args) {
        new OrderPizza(new BJFactory());
    }
}

工厂模式小结

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

2)三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式)

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

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

注：本文章大量借鉴尚硅谷公开视频资料的内容，如有不妥之处立即删除。对文章有不懂的地方，可以直接去尚硅谷的官方网站学习。