目录
1. 摘要
本篇文章主要讲述23种设计模式中的工厂方法模式。
这里我们用一个咖啡店系统的小案例来引出简单工厂模式的使用，在简单工厂模式的基础上延申介绍工厂方法模式。
2. 需求案例(设计一个咖啡店的点餐系统)
2.1 咖啡父类及其子类
如图所示，我们知道咖啡有很多种，美式咖啡，拿铁咖啡......，所以在这个系统中，不难发现咖啡类Coffee应该定义为父类，又因为所有咖啡都会加糖加奶，所以定义addMilk()，addSugar()方法让子类继承即可，此外咖啡都有不同的名字，所以定义一个抽象方法getName()。
然后让所有准确的咖啡类都继承我们的咖啡父类，使用实线空心三角箭头表示继承关系；
2.2 咖啡店类与咖啡类的关系
咖啡店可以点咖啡，所以定义方法名为 "orderCoffee"，方法参数就是顾客点的咖啡名称，方法返回值就是顾客点的咖啡对象；咖啡店类依赖咖啡类，是用虚线箭头指向被依赖类Coffee。
3. 普通方法实线咖啡店点餐系统
这里我们先用最直接粗暴的方式实现上面的咖啡点餐系统，非常简单，主要分为以下几步
3.1 定义Coffee父类
public abstract class Coffee {
// 加奶方法
public void addMilk() {
System.out.println("add milk");
}
// 加糖方法
public void addSugar() {
System.out.println("add sugar");
}
// 定义抽象方法，获取咖啡名称，由子类实现
public abstract String getName();
}
3.2 定义美式咖啡类继承Coffee类
public class AmericanCoffee extends Coffee{
@Override
public String getName() {
return "美式咖啡";
}
}3.3 定义拿铁咖啡继承Coffee类
public class LatteCoffee extends Coffee{
@Override
public String getName() {
return "拿铁咖啡";
}
}3.4 定义咖啡店类
public class CoffeeStore {
public Coffee orderCoffee(String type) {
Coffee coffee = null;
if ("美式咖啡".equals(type)) {
coffee = new AmericanCoffee();
}else if ("拿铁咖啡".equals(type)) {
coffee = new LatteCoffee();
}else {
throw new RuntimeException("抱歉，不支持这种咖啡");
}
coffee.addMilk();
coffee.addSugar();
return coffee;
}
}3.5 编写测试类
public class TestCoffee {
public static void main(String[] args) {
// 创建咖啡店类
CoffeeStore coffeeShop = new CoffeeStore();
// 点咖啡
Coffee coffee = coffeeShop.orderCoffee("美式咖啡");
System.out.println(coffee.getName());
}
}运行方法可以看到方法执行已经成功，达到了目的。
但是这种做法有一个问题，就是项目中类与类之间的耦合度太高了，如果现在我再提一个新的需求。
想要添加一个新的咖啡品种，于此带来的影响就是咖啡店类中的"orderCoffee"方法逻辑需要重新做修改，这样做就违背了Java中"对修改关闭，对扩展开发的"的开发原则，是非常不友好的。因此，普通做法虽然简单粗暴，能够以最快的速度达到目的，却忽略了项目的可扩展性与程序的健壮性。
4. 简单工厂方法实线咖啡点餐系统
4.1 简单工厂方法模式概述
简单工厂模式并不属于23种设计模式的一种，但它在实际开发中也比较常用，用的人多了，就成了一种编程习惯，恰好借此机会我们一起来看看简单工厂模式的做法。
简单工厂主要包含以下几种角色：
（1）抽象产品：定义了产品的规范，描述了产品的主要特性和功能，对应咖啡点餐系统中的Coffee父类，父类中定义了加奶和加糖等共有属性；
（2）具体产品：实现或继承了抽象产品的子类，对应咖啡点餐系统中的美式咖啡AmericanCoffee，拿铁咖啡LatteCoffee；
（3）具体工厂：提供创建产品的方法，调用者通过该方法获取产品。具体工厂就是简单工厂方法中我们要新增的工厂类。
4.2 引入咖啡工厂
如下图所示，我们做项目总是调侃一句话，没有什么问题是加一层无法解决的，如果解决不了，就加两层......
在简单工厂方法中，我们就需要在Coffee咖啡类和CoffeStore咖啡店中间加一层，创建 SimpleCoffeeFactory 咖啡工厂类，由咖啡工厂负责生产咖啡，当咖啡店有人点餐时，直接调用咖啡工厂的 createCoffee() 创建咖啡方法，方法返回值为Coffee。
对比普通普通方法，我们需要创建SimpleCoffeeFactory咖啡工厂类，再将CoffeeStore咖啡店类中点咖啡方法做修改，如下所示
SimpleCoffeeFactor 咖啡工厂类；
public class SimpleCoffeeFactory {
public Coffee createCoffee(String type) {
Coffee coffee = null;
if ("美式咖啡".equals(type)) {
coffee = new AmericanCoffee();
}else if ("拿铁咖啡".equals(type)) {
coffee = new LatteCoffee();
}else {
throw new RuntimeException("抱歉，不支持这种咖啡");
}
// 这里我们生产完毕咖啡直接返回，将加糖或加奶的决定权交给顾客
return coffee;
}
}4.3 修改 CoffeeStore 咖啡店类逻辑
可以看到，我们将咖啡类和咖啡店类进行解耦，让咖啡工厂作为二者的中间桥梁，如果后续我们要添加其他品种的咖啡，直接修改咖啡工厂的代码逻辑即可，咖啡类Coffee和咖啡店类CoffeeStore都不会受到任何影响。
而且，我们给了顾客选择，
顾客只想加糖，就调用 orderCoffeeOnlySugar 方法；
顾客只想加奶，就调用 orderCoffeeOnlyMilk 方法；
如果都不想加，可以再创建另外一个方法，极大地简化了代码量。
public class CoffeeStore {
// 创建一个咖啡工厂的对象
SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
public Coffee orderCoffeeOnlySugar(String type) {
Coffee coffee = factory.createCoffee(type);
coffee.addSugar();
return coffee;
}
public Coffee orderCoffeeOnlyMilk(String type) {
Coffee coffee = factory.createCoffee(type);
coffee.addMilk();
return coffee;
}
}4.4 编写测试类
只需要创建 SimpleCoffeeFactory 咖啡工厂对象，我们就可以调用咖啡工厂对象的方法，传入我们希望得到的咖啡，此时，咖啡类和咖啡店类就完成了解耦合。
public static void main(String[] args) {
SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
// 点咖啡
Coffee coffee = factory.createCoffee("拿铁咖啡");
System.out.println(coffee.getName());
System.out.println("--------------------------------");
Coffee coffee1 = factory.createCoffee("美式咖啡");
System.out.println(coffee1.getName());
}
4.5 简单工厂方法相较于普通方法的优点
如果我们采用最原始的方法点一杯只加糖和只加奶的咖啡，代码逻辑如下，可以看到，每当用户点一杯咖啡，我们就要写一次咖啡的判断逻辑并创建咖啡，非常麻烦。
因此，我们就可以将公共的判断咖啡种类和创建咖啡的公共部分抽取出来，交给咖啡工厂去完成，这样一来就可以节省大量代码，使项目中各部分的代码耦合度降低；
public class CoffeeStore {
public Coffee orderCoffeeOnlySugar(String type) {
Coffee coffee = null;
if ("美式咖啡".equals(type)) {
coffee = new AmericanCoffee();
}else if ("拿铁咖啡".equals(type)) {
coffee = new LatteCoffee();
}else {
throw new RuntimeException("抱歉，不支持这种咖啡");
}
coffee.addSugar();
return coffee;
}
public Coffee orderCoffeeOnlyMilk(String type) {
Coffee coffee = null;
if ("美式咖啡".equals(type)) {
coffee = new AmericanCoffee();
}else if ("拿铁咖啡".equals(type)) {
coffee = new LatteCoffee();
}else {
throw new RuntimeException("抱歉，不支持这种咖啡");
}
coffee.addMilk();
return coffee;
}
5. 工厂方法模式实线咖啡点餐系统
5.1 分析简单工厂模式的缺点，引出工厂方法模式
刚才我们使用了简单工厂方法实线了点咖啡的案例，但我们也可以发现这种方法的缺点，就是仍然违背了 "对修改开发，对扩展封闭" 的原则。
使用了咖啡工厂之后，我们只需要将生产咖啡交给工厂来完成。但是，如果我们要增加一种新的咖啡，还是需要修改咖啡工厂中的代码逻辑，我们将新需求带来的影响缩小到了咖啡工厂这个类中，但还是需要做修改，违背了开闭原则。
但如果我们使用工厂方法模式，就不会违背开闭原则，它的做法是定义一个创建对象的接口，让子类决定实例化哪种产品。
工厂方法模式的主要角色：
（1）抽象工厂(Abstract Factory)：提供创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
（2）具体工厂(Concreate Factory)：主要实现抽象工厂中的抽象方法，完成产品的创建。
（3）抽象产品(Abstract Product)：定义产品的规范，描述了产品的主要功能和特性。
（4）具体产品(Concreate Product)：实线了抽象产品角色定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。
5.2 引入抽象咖啡工厂
在简单工厂方法模式中，我们将生产咖啡提取成一个工厂，让工厂生产咖啡。但实际上，咖啡工厂仍然可以做进一步的抽象，让子类去实线抽象工厂中的方法。这样一来，当我们需要新增一种咖啡时，只需要新增一个咖啡工厂的实现类，其他的都不需要做任何改变。
5.3 修改咖啡工厂的代码
对比简单工厂，抽象咖啡类Coffee，子类AmericanCoffee和LatteCoffee都不用改变；
新建抽象咖啡工厂类：
public interface CoffeeFactory {
// 创建咖啡对向的方法
AmericanCoffee createCoffee();
}创建美式咖啡工厂类实线抽象咖啡工厂接口，此工厂专门生产美式咖啡：
public class AmericanCoffeeFactory implements CoffeeFactory{
@Override
public AmericanCoffee createCoffee() {
return new AmericanCoffee();
}
}创建拿铁咖啡工厂类实线抽象咖啡工厂接口，此工厂专门生产拿铁咖啡：
public class LatteCoffeeFactory implements CoffeeFactory{
@Override
public LatteCoffee createCoffee() {
return new LatteCoffee();
}
}修改咖啡店类点咖啡的代码逻辑，这里几乎没有很大变化，关键点在于创建的咖啡工厂对象为顶层父接口对象，我们只需要通过父接口对象调用 createCoffee() 对象；
public class CoffeeStore {
private CoffeeFactory coffeeFactory;
public void setCoffeeFactory(CoffeeFactory coffeeFactory) {
this.coffeeFactory = coffeeFactory;
}
public Coffee createCoffee(String orderType) {
Coffee coffee = coffeeFactory.createCoffee();
coffee.addMilk();
coffee.addSugar();
return coffee;
}
}5.4 编写测试类
public static void main(String[] args) {
// 创建咖啡店对象
CoffeeStore store = new CoffeeStore();
// 创建拿铁咖啡工厂对象，父类引用指向子类对象
CoffeeFactory latteCoffeeFactory = new LatteCoffeeFactory();
store.setCoffeeFactory(latteCoffeeFactory);
// 点咖啡
Coffee coffee = store.createCoffee("拿铁咖啡");
System.out.println(coffee.getName());
}运行测试类，我们就会得到拿铁咖啡工厂生产的拿铁咖啡
5.5 工厂方法模式的优缺点
优点：实线了代码之间的解耦，模块之间耦合度降低。当系统要添加新的产品类时，只需要添加具体产品类和具体工厂类，无需对原有工厂作出修改，满足开闭原则。
举例：当我们想要增加新品种的咖啡时(比如香草咖啡)，只需要在创建一个香草咖啡工厂去实现咖啡工厂接口；再创建一个香草咖啡类继承咖啡父类，不需要对以往的代码作出修改，只在原有的代码上做增加。
缺点：每增加一种产品，就需要增加一个产品工厂类和一个具体产品类，随着产品越来越多，会导致系统中的代码越来越多越来越复杂，增加了系统的复杂度，不易维护。