设计模式之——工厂模式
一、学习内容：
所有的 工厂模式 都是通过减少应用程序和具体类之间的依赖，促进松耦合。
所有的 工厂 都是用来封装对象的创建。
1.简单工厂
简单工厂并非设计模式，但是确是将客户程序从具体类中解耦的一个简单方法，被经常使用。
2.工厂方法：
定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。
3.依赖倒置原则：
让我们避免依赖具体类型，尽量依赖抽象。
4.抽象工厂：
抽象工厂使用对象组合，对象的创建被实现在工厂接口所暴露的方法中。它提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体的类。
二、目的：
可以将对象的创建封装起来，以便于得到更松的耦合，更有弹性的设计。
三、用途：
两种模式都是将对象创建的过程封装起来，以便将代码从具体的类中解耦。
四、基础和原则
面向对象(Object Oriented ->OO)：
就是基于对象概念，以对象为中心，以类和继承为构造机制，充分利用接口和多态提供灵活性来认识、理解、刻划客观世界和设计、构建相应的软件系统。
1. OO基础抽象：
①.抽象：先不考虑细节
②.封装：隐藏内部实现
③.多态：复用现有代码
④.继承：改写对象行为
2. OO原则：
①. 多用组合，少用继承
②. 针对接口编程，不针对实现编程
③. 为交互对象间的松耦合设计而努力
④. 类对扩展开放，对修改关闭
⑤. 依赖抽象不依赖具体的类
下面让我们开始吧！
以披萨店为例，介绍以上四个内容。
一、简单工厂：
1.如果现在要开一个 Pizza 店，下面是定 Pizza的代码：
public Pizza orderPizza() {
Pizza pizza = new Pizza();
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
2.如果现在需要更多类型的 Pizza, 代码会变成下面这样：
public Pizza orderPizza(String type) {
Pizza pizza;
if(type.equals("cheese"))
pizza=new ChicagoPizzaStore.ChicagoCheesePizza(ingredientFactory);
else if(type.equals("pepperoni"))
pizza=new ChicagoPizzaStore.ChicagoPepperoniPizza();
else if(type.equals("clam"))
pizza=new ChicagoPizzaStore.ChicagoClamiPizza();
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
3.但是如果我们需要更改 Pizza 的类型，那么就需要对下面这一段进行不断的修改，你会发现，如果实例化的过程在orderPizza（）中就无法使它对修改关闭。
if(type.equals("cheese"))
pizza=new ChicagoPizzaStore.ChicagoCheesePizza(ingredientFactory);
else if(type.equals("pepperoni"))
pizza=new ChicagoPizzaStore.ChicagoPepperoniPizza();
else if(type.equals("clam"))
pizza=new ChicagoPizzaStore.ChicagoClamiPizza();
4.下面来创建一个简单的工厂，用来封装创建 Pizza 对象的代码
工厂代码：
public class SimplePizzaFactory {
public Pizza creatPizza(String type) {
Pizza pizza=null;
if (type.equals("cheese"))
pizza = new NYPizzaStore.NYCheesePizza(ingredientFactory);
else if (type.equals("pepperoni"))
pizza = new NYPizzaStore.NYPepperoniPizza(ingredientFactory);
else if (type.equals("clam"))
pizza = new NYPizzaStore.NYClamiPizza(ingredientFactory);
return pizza;
}
}
客户代码：
public class PizzaStore{
SimplePizzaFactory factory;
public PizzaStore(SimplePizzaFactory factory){
this.factory=factory;
}
public Pizza orderPizza(String type) {
Pizza pizza;
pizza = factory.craetPizza(type);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
}
总结： 这样做就可以将创建Pizza的代码封装进 SimplePizzaFactory 这个类中，当我们需要修改时就直接到这里来修改即可。对于一个客户来说，问题当然并没有简化，但是 SimplePizzaFactory 可以有多个客户，这样一来就实现了将客户程序从具体类中解耦，方便扩展多个客户。下面是类图，PizzaStore 可以有多个，需要修改的地方就只有creatPizza() 方法中的内容。
二、工厂方法：
上面已经实现了扩展多个用户，但是现在又有了新的问题--->每个加盟的 Pizza 店都要制造具有当地特色的 Pizza 怎么办？可以让每个加盟店都有自己的工厂，但是这样做不就回到了问题最开始的样子了吗？
1. 有一种办法就是使用 PizzaStore 框架：
框架？ -> 制定一套规范（思想）、实现基础功能的同时，具有可靠性、可伸缩、定制、扩展、维护等。
public abstract class PizzaStore {
public Pizza orderPizza(String type) {
Pizza pizza;
pizza = creatPizza(type);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
//创建pizza的工厂方法
public abstract Pizza creatPizza(String type);
//其他的工厂方法...
}
PizzaStore 作为一个超类（Super Class)，其他的Store 都继承PizzaStore ，每个继承PizzaStore 的子类各自决定如何制造Pizza。这样超类中的orderPizza 方法对Pizza对象做了很多工作如：准备、烘烤、切片等，但是它并不知道实际是哪些具体的类完成了这些工作，即实现了封装。 而实际的Pizza对象是由具体的子类PizzaStore所决定的，但真正做决定的是 顾客 本身在哪一家pizza店点了什么pizza。
2. 下面在纽约开一家Pizza店只需要继承PizzaStore 然后实现它的方法：
public class NYPizzaStore extends PizzaStore {
@Override
public Pizza creatPizza(String type) {
Pizza pizza = null;
PizzaIngredientFactory ingredientFactory=new NYIngredientFactory();
if (type.equals("cheese"))
pizza = new NYPizzaStore.NYCheesePizza(ingredientFactory);
else if (type.equals("pepperoni"))
pizza = new NYPizzaStore.NYPepperoniPizza(ingredientFactory);
else if (type.equals("clam"))
pizza = new NYPizzaStore.NYClamiPizza(ingredientFactory);
return pizza;
}
芝加哥也是如此。 And so on ...
public class ChicagoPizzaStore extends PizzaStore {
@Override
public Pizza creatPizza(String type) {
........
}
以上过程，工厂方法已经完成了对象创建的处理，并将这些行封装在子类中，这样实现了客户程序中超类代码和子类创建的代码解耦。
**3. ** 下面是为了实现订购pizza的 辅助代码：Pizza的抽象类 、Pizza的实现类和测试类。
Pizza抽象类：
public abstract class Pizza {
public String name;
public Dough dough;
public Sauce sauce;
public Cheese cheese;
public ArrayList toppings=new ArrayList();
public abstract void prepare();
void bake(){
System.out.println("烘烤25分钟");
}
public void cut(){
System.out.println("对角线切");
}
void box(){
System.out.println("官方店的包装盒");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String toString(){
return ""; //打印 Pizza的代码
}
纽约CheesePizza实现类: And so on ...
public class NYCheesePizza extends Pizza {
PizzaIngredientFactory ingredientFactory;
public NYCheesePizza(PizzaIngredientFactory factory) {
this.ingredientFactory = factory;
}
@Override
public void cut() {
System.out.println("对角切块");
}
@Override
public void prepare() {
name="纽约Cheese披萨";
System.out.println("准备" + name);
System.out.println("和面");
System.out.println("加调味料");
System.out.println("加芝士");
dough = ingredientFactory.creatDough();
sauce = ingredientFactory.creatSauce();
cheese = ingredientFactory.creatCheese();
}
}
测试类：
public class PizzaTest {
public static void main(String args[]) {
PizzaStore nyStore = new NYPizzaStore();
PizzaStore chicagoStore = new ChicagoPizzaStore();
Pizza pizza_1 = nyStore.orderPizza("cheese");
System.out.println("这是 Ethan 定的一个" + pizza_1.getName() + "\n");
Pizza pizza_2 = chicagoStore.orderPizza("cheese");
System.out.println("这是 Joel 定的一个" + pizza_2.getName() + "\n");
}
}
总结： 工厂方法就是让子类来决定要创建的对象是什么，通过子类将对象的创建过程封装起来。但是并不是指子类本身在运行时做决定，而是在编写创建者类时，不需要知道实际创建的产品是什么。
三、依赖倒置原则 ：
设计原则：依赖抽象，不依赖具体的类。
1. 不能让高层组件依赖低层组件，而且高层组件和低层组件都依赖于抽象。
注：高层组件：有其他低层组件定义其行为的类。 如：PizzaStore是高级组件，它的行为由Pizza定义,
这里低层组件就是Pizza的实现
2. 上例中高层组件（PizzaStore）和低层组件（xxx pizza） 都依赖了Pizza这个抽象.
3. 倒置在哪里？
以前的依赖方式是自上而下的，而现在低层的组件现在依赖高层的抽象，而高层抽象也依赖与之相同的抽象。这样的原则会倒置你的思考方式，实现一个披萨店你的思考方式由下面的①转到②。
①.披萨店 -> 准备、烘烤... -> 不同口味的Pizza
②.共享一个Pizza接口，抽象出一个Pizza -> 披萨店的设计
倒置使得你在设计Pizza店的时候不需要考虑具体的Pizza类。
四、抽象工厂：
pizza的关键还在于原料的好坏，而各地PizzaStore 都需要一组原料，要想解决这一问题就要处理好原料家族。即为每一个区域创建一个原料工厂，而这些工厂都是实现 PizzaIngredientFactory接口。
工厂接口：
public interface PizzaIngredientFactory {
Dough creatDough();
Sauce creatSauce();
Cheese creatCheese();
//其他....
}
实现纽约工厂：
public class NYIngredientFactory implements PizzaIngredientFactory {
//纽约的原料工厂具有纽约的特色 具体不在写入
@Override
public Dough creatDough() {
return new NYDough();
}
@Override
public Sauce creatSauce() {
return new NYSauce();
}
@Override
public Cheese creatCheese() {
return new NYCheese();
}
有了工厂就要使用工厂原料了，需要改写Pizza超类和其子类。
pizza类做如下改变：
①。加入会用到的原料
②。prepare 声明为抽象方法，用来从工厂收集披萨所需的原料
public abstract class Pizza {
public String name;
public Dough dough;
public Sauce sauce;
public Cheese cheese;
public ArrayList toppings=new ArrayList();
public abstract void prepare();
}
Pizza的子类做如下改变：从构造器中得到工厂，需要的原料都从工厂要。
public class NYPizzaStore extends PizzaStore {
@Override
public Pizza creatPizza(String type) {
Pizza pizza = null;
PizzaIngredientFactory ingredientFactory=new NYIngredientFactory();
if (type.equals("cheese"))
pizza = new NYPizzaStore.NYCheesePizza(ingredientFactory);
else if (type.equals("pepperoni"))
pizza = new NYPizzaStore.NYPepperoniPizza(ingredientFactory);
else if (type.equals("clam"))
pizza = new NYPizzaStore.NYClamiPizza(ingredientFactory);
return pizza;
}
纽约PizzaStore使用纽约的原料工厂
public class NYPizzaStore extends PizzaStore {
@Override
public Pizza creatPizza(String type) {
Pizza pizza = null;
PizzaIngredientFactory ingredientFactory=new NYIngredientFactory();
if (type.equals("cheese"))
pizza = new NYPizzaStore.NYCheesePizza(ingredientFactory);
else if (type.equals("pepperoni"))
pizza = new NYPizzaStore.NYPepperoniPizza(ingredientFactory);
else if (type.equals("clam"))
pizza = new NYPizzaStore.NYClamiPizza(ingredientFactory);
return pizza;
}
以上Pizza利用所依赖的共仓来生产原料，根本不用关心这些原料的制作。如此一来，Pizza就和原料之间实现解耦。
[图片上传失败...(image-ae9c5b-1545546881951)]
总结： 我们创建了抽象的工厂，通过抽象工厂提供的接口来创建原料家族。利用接口将我们的代码从实际的工厂中解耦，这样实际的产品也可以使用不同的工厂。工厂方法就潜伏在抽象工厂中，实际上抽象工厂的每个方法都声明成抽象，其子类覆盖这些方法来创建对象，这就是工厂方法。
让我们再回顾一下开篇的内容，或许能对工厂模式有一个新的理解和认识：
1.简单工厂
简单工厂并非设计模式，但是确是将客户程序从具体类中解耦的一个简单方法，被经常使用。
2.工厂方法：
定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。
3.依赖倒置原则：
让我们避免依赖具体类型，尽量依赖抽象。
4.抽象工厂：
抽象工厂使用对象组合，对象的创建被实现在工厂接口所暴露的方法中。它提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体的类。
Author：瞌睡遇上枕头
Email：Beyonderwei@163.com
