2.简单工厂模式

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

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

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

来看一个订购面包的实例，要求程序具有可扩展性

1）面包的种类很多，（ButterBread, Toast...)

2）制作过程，(prepare, bake, pack)

3）完成面包的订购功能

2.1? 传统的方法

思路:

????????需要用到的类，Bread抽象类，ButterBread,Toast具体的实现类，OrderBread面包的订购类??

? ? ? ? 具体实现，在OrderBread中完成对不同种类面包的订购

UML类图?

? ? ? ?? ? ?

?代码

//Bread.java
public abstract class Bread {
    protected String type;

    //用于给设置type的值
    public void setType(String type) {
        this.type = type;
    }

    //准备面包材料
    public void prepare() {
        System.out.println("正在准备" + type + "面包的材料");
    }

    //烘焙面包
    public void bake() {
        System.out.println(type + "正在烘焙中");
    }

    //打包面包
    public void pack() {
        System.out.println(type + "正在打包中");
    }
}

class Toast extends Bread {
}

class ButterBread extends Bread {
}


//OrderBread.java
public class OrderBread {
    public void orderBread() {

        while(true) {
            String type = getType();
            Bread bread;
            if ("Toast".equalsIgnoreCase(type)) {
                bread = new ButterBread();
                bread.setType("Toast");
            } else if ("ButterBread".equalsIgnoreCase(type)) {
                bread = new Toast();
                bread.setType("ButterBread");
            } else {
                break;
            }
            //输出面包的订购过程
            if (bread != null) {
                bread.prepare();
                bread.bake();
                bread.pack();
                System.out.println("----------------------------");
            }
        }
    }

    //可以获取客户希望订购的面包种类,就是从控制台上获取输入数据
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input Bread 种类:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

//main测试代码
public static void main(String[] args) {
    OrderBread orderBread = new OrderBread();
    orderBread.orderBread();
}

?测试结果?

input pizza 种类:
toast
正在准备Toast面包的材料
Toast正在烘焙中
Toast正在打包中
----------------------------
input pizza 种类:
butterbread
正在准备ButterBread面包的材料
ButterBread正在烘焙中
ButterBread正在打包中
----------------------------
input pizza 种类:

存在问题

1.让我们看看如果增加一种面包（WholeWheatBread）会发生什么

可以看到图中两条红线的情况，主要的改动是添加了一个类，OrderBread中需要修改if分支的代码

2.上一种情况看似问题不是很大，指修改了两个部分，那么如果我们的店铺扩张，又要添加新的订购类呢？就会变成如下情况

而这时如果我们在添加一种面包，需要同时改动OrderBread1与OrderBread2，需要改动的地方直接翻倍。

可以看到，这种方式随着类的增多，是十分不利于扩展和维护的。类越多，增加扩展所需要的改动就越多，稍有不慎就有可能遗漏，发生错误。

2.2? 简单工厂模式

思路：

新增一个SimpleFactory类，将面包的订购过程转移到该类的内部，让其他的Order类依赖SimpleFactory类，使得各种Order类与面包之间不存在依赖关系。另各种Order类转而依赖SimpleFactory类。

UML类图

?代码(只包括修改或者新增的类)

//OrderBread.java
public class OrderBread {
    private SimpleFactory simpleFactory = new SimpleFactory();
    public void orderBread() {

        while (true) {
            Bread bread = simpleFactory.createBread(getType());
            //输出面包的订购过程
            if (bread != null) {
                bread.prepare();
                bread.bake();
                bread.pack();
                System.out.println("----------------------------");
            } else {
                System.out.println("订购失败");
                break;
            }
        }
    }

    //可以获取客户希望订购的面包种类,就是从控制台上获取输入数据
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input Bread 种类:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}


//新建立的SimpleFactory类
public class SimpleFactory {
    //将Order类中创建面包的过程移动到此处
    public Bread createBread(String type) {
        Bread bread = null;
        if ("Toast".equalsIgnoreCase(type)) {
            bread = new ButterBread();
            bread.setType("Toast");
        } else if ("ButterBread".equalsIgnoreCase(type)) {
            bread = new Toast();
            bread.setType("ButterBread");
        }
        return bread;
    }
}