一、概述

什么是工厂模式？

工厂模式(Factory Pattern)是最常见的一种设计模式之一。它主要是提供一种创建对象的最佳方法！

为什么要学习工厂模式？

与通过new来创建对象不同，使用工厂模式创建对象不会对客户端暴露创建逻辑，并且是通过统一个共同的接口指向新创建的对象。同事工厂模式能将创建对象的代码集中在一个对象或者方法中，可以避免代码中的重复，并且更方便维护。面向接口编程，这样的代码更具有弹性，可以应对未来的扩展。

二、认识工厂模式

案例：假设你有一个Pizza店，每天要做出不同口味的Pizza。

假设我们有两种口味Pizza

/*

* 抽象的Pizza类，Pizza制作一般包括准备，烘烤，切块，包装。

*/

public abstract class Pizza{

// Pizza名称

protected String name;

// 面团类型

protected String dough;

// 酱料

protected String sauce;

// 芝士

protected String cheese;

// 蛤蜊

protected String clam;

// 佐料

protected List toppings = new ArrayList();

// 准备

public void prepare() {

System.out.print("准备食材，添加调料:");

for (int i = 0; i < toppings.size(); i++) {

System.out.print(toppings.get(i)+" ");

}

};

// 烘烤

public void bake() {

System.out.println("烘烤20分钟...");

};

// 切块

public void cut() {

System.out.println("切成x块...");

};

// 包装

public void box() {

System.out.println("包装...");

}

// setter 和 getter方法省略

}

芝加哥风味的芝士Pizza

public class ChicagoStyleCheesePizza extends Pizza{

public ChicagoStyleCheesePizza() {

name = "Chicago Style Deep Dish Cheese Pizza";

dough = "Extra Thick Crust Dough";

sauce = "Plum Tomato Sauce";

toppings.add("Shredded Mozzarella Cheese");

}

public void cut() {

System.out.println("Cut the pizza into square slices");

}

}

纽约风味的蔬菜Pizza

public class NyStyleVeggiePizza extends Pizza{

public NyStyleVeggiePizza() {

name = "NY style Sauce and Veggie Pizza";

dough = "Thin Crust Dough";

sauce = "Marinara Sauce";

toppings.add("Grated Reggiano Veggie");

}

}

纽约风味的芝士Pizza

public class NyStyleCheesePizza extends Pizza{

public NyStyleCheesePizza() {

name = "NY style Sauce and Cheese Pizza";

dough = "Thin Crust Dough";

sauce = "Marinara Sauce";

toppings.add("Grated Reggiano Cheese");

}

}

通过new创建对象

// 创建一个纽约风味的芝士Pizza

NyStyleCheesePizza nyPizza = new NyStyleCheesePizza();

当使用new得到一个对象时，确实得到了一个具体类，是针对具体类实现，而不是接口。代码绑定具体类会导致代码脆弱，更缺乏弹性。

简单工厂

public class SimplePizzaFactory {

public Pizza createPizza(String type) {

Pizza pizza = null;

if (type.equals("NyStyleCheesePizza")) {

return new NyStyleChieesePizza();

} else if(type.endsWith("ChicagoStyleCheesePizza")) {

return new ChicagoStyleCheesePizza();

}else {

return null;

}

}

}

// 创建简单工厂对象

SimplePizzaFactory pizzaFactory = new SimplePizzaFactory();

// 创建Pizza对象

NyStyleChieesePizza myPizza = pizzaFactory.createPizza("NYStyleChieesePizza");

简单工厂将对象的创建过程进行了封装，用户不需要知道具体的创建过程，只需要调用工厂类获取对象即可。

这种简单工厂的写法是通过if else来判断对象创建过程的。简单工厂只是把new对象的问题转移到另一个类中在实际使用过程中，违背了 开放-关闭原则，当然有些情况下可以通过反射调用来弥补这种不足。

工厂方法模式

定义：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

// 抽象的Pizza工厂

public abstract class PizzaFactory {

public Pizza getPizza(String type) {

Pizza pizza;

pizza = createPizza(type);

pizza.prepare();

pizza.bake();

pizza.cut();

pizza.box();

return pizza;

}

protected abstract Pizza createPizza(String pizza);

}

// 纽约Pizza工厂(芝加哥pizza工厂跟这个类似)

public class NYPizzaFactory extends PizzaFactory {

protected Pizza createPizza(String type) {

if (type.equals("NyStyleChieesePizza")) {

return new NyStyleCheesePizza();

} else if (type.equals("NyStyleVeggiePizza")) {

return new NyStyleVeggiePizza();

}else {

return null;

}

}

}

通过工厂方法创建对象

PizzaFactory pizzaFactory = new NYPizzaFactory();

// 创建一个蔬菜披萨

Pizza pizza = pizzaFactory.createPizza("NyStyleVeggiePizza");

当使用工厂方法创建对象时，是在编写具体工厂类时决定创建的对象时哪一个，选择使用哪个工厂类，自然就决定了十几创建的是哪个对象。尽管只有一个具体工厂，工厂方法还是非常有用的！因为它将对象从“实现”从“使用”中解耦，如果增加对象或者改变对象，工厂是不会受到影响的！

抽象工厂模式

定义：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

抽象原料工厂

// 为了简化， 这里的原料用字符串表示，其实每个原料应该用一个类表示

public interface PizzaIngredientFactory {

public String createDough();

public String createSauce();

public String createChieese();

public String[] createVeggies();

public String createPepperoni();

}

芝士pizza原料工厂

public class CheesePizzaIngredientFactory implements PizzaIngredientFactory {

public String createDough() {

return "薄地壳比萨生面团";

}

public String createSauce() {

return "纽约专用蘸料";

}

public String createChieese() {

return "Reggiano干酪";

}

public String[] createVeggies() {

return new String[]{"洋葱","生菜","香菇"};

}

public String createPepperoni() {

return "意大利辣香肠";

}

}

创建pizza工厂

public class ChinaPizzaFactory extends PizzaFactory {

public Pizza createPizza(String type) {

Pizza pizza = null;

PizzaIngredientFactory ingredientFactory = new ChinaPizzaIngredientFactory();

if(type.equals("cheese")) {

pizza = new CheesePizza(ingredientFactory);

pizza.setName("中国芝士pizza");

}else if (type.equals("clam")) {

pizza = new ClamPizza(ingredientFactory);

pizza.setName("中国蛤蜊pizza");

}

return pizza;

}

}

// 具体的Pizza类

public class ClamPizza extends Pizza {

PizzaIngredientFactory ingredientFactory;

public ClamPizza(PizzaIngredientFactory pizzaIngredientFactory) {

this.ingredientFactory = pizzaIngredientFactory;

}

public void prepare() {

System.out.println("Preparinging" + name);

// 根据pizza本身的特点，从工厂中获取自己需要的原料

dough = ingredientFactory.createDough();

sauce = ingredientFactory.createSauce();

clam = ingredientFactory.creatClam();

}

}

创建一个中国蛤蜊pizza

// 创建一个Pizza工厂

PizzaFactory pizzaFactory = new ChinaPizzaFactory();

Pizza clamPizza = pizzaFactory.createPizza("clam");

抽象工厂模式将'对象' 与 ‘’组成对象或者对象依赖的类‘’解耦。

三、对比与分析

通过new来创建对象是面向具体类编程，扩展性差！

简单工厂把全部的事情都在一个地方处理完了，但是当有新增或者修改的对象类时，很难进行扩展，违反了开闭原则。简单工厂并不能算是工厂模式，而是一种编程习惯，或者是一种方法的封装，并不具备弹性。

工厂方法是创建一个框架，让子类决定如何实现。虽然可能导致类会变多，代码稍微复杂，但是这样做最大的好处是更具有弹性。

工厂模式的好处：将创建对象的代码集中在一个对象或者方法中，可以避免代码中重复的代码，并且方便以后的维护。依赖接口，而不是具体的类。

如何选择？

当需要将对象家族和具体的对象集合结合起来时，可以使用抽象工厂。

当需要将客户代码从需要实例化的具体类中解耦，或者目前还不中知道将来实例化哪些具体类时，可以使用工厂方法。