工厂模式——简单工厂模式

工厂模式

尚硅谷java设计模式课程

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

简单工厂模式

​ ——又叫静态工厂模式

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

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

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

案例:

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

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

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

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

使用传统方法实现：

思路分析（类图）

抽象类Pizza

public abstract class Pizza {
    private String name;

    public abstract void prepare();

    public void bake() {//披萨烘烤的方法
        System.out.println(name + "披萨烘烤的方法");
    }

    public void cut() {
        System.out.println(name + "披萨切割的方法");
    }

    public void box() {
        System.out.println(name + "披萨打包的方法");
    }

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

两个实例去实现Pizza

1）CheesePizza

public class CheesePizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("准备Cheess的原材料。");
    }
}

2）GreekPizza

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

OrderPizza类（订购披萨）

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 {
                    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 "";
        }
    }
}

PizzaStore启动类

public class PizzaStore {
    public static void main(String[] args) {
       //new OrderPizza();
        new OrderPizza(new SimplePizza());
    }

}

传统的方式的优缺点

1. 优点是比较好理解，简单易操作。

2. 缺点是违反了设计模式的 ocp 原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码.

3. 比如我们这时要新增加一个 其他 的种类(Pepper 披萨)，我们需要做如下修改. 如果我们增加一个 Pizza 类，只要是订购 Pizza 的代码（OrderPizza）都需要修改.

4. 改进的思路分析

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

的代码，往往有多处。

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

对象的代码就不需要修改了—> 简单工厂模式

使用简单工厂模式

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

代码

1）简单工厂类SimpleFactory

//简单工厂类
public class SimpleFactory {
    public Pizza createPizzza(String orderType){
        Pizza pizza = null;
        if (orderType.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName(" 希腊披萨 ");
        } else if (orderType.equals("cheese")) {
            pizza = new CheesePizza();
            pizza.setName(" 奶酪披萨 ");
        }
        return pizza;//如果找到对应的类型披萨就返回对应披萨。没有就返回null
    }
}

下订单类（OrderPizza）

public class OrderPizza {
    //定义一个简单工厂对象
    SimpleFactory simpleFactory;
    Pizza pizza = null;
    //构造器
    public OrderPizza(SimpleFactory simpleFactory){
        setFactory(simpleFactory);

    }
    public void setFactory(SimpleFactory simpleFactory){
        String orderType = "";//用户输入
        this.simpleFactory = simpleFactory;
        do {
            orderType = getType();
            pizza = simpleFactory.createPizzza(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 "";
        }
    }
}

简单工厂的优缺点：

优点

1）使用简单工厂后我们需要新加其他种类时只需要创建好该类后，在工厂类中添加即可

2）工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；简单工厂模式通过这种做法实现了对责任的分割，它提供了专门的工厂类用于创建对象。

3）客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量。

4）通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性。

缺点

1）由于工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。

2）使用简单工厂模式将会增加系统中类的个数，在一定程序上增加了系统的复杂度和理解难度。

3）系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，同样破坏了“开闭原则”；在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。

4）简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。