概述

需求

设计一个咖啡店点餐系统
设计一个咖啡类（Coffee）；并定义其两个子类（美式咖啡AmericanCoffee和拿铁咖啡LatteCoffee）；再设计一个咖啡店类（CoffeeStore），其具备点咖啡的功能。

类图

咖啡类

public abstract class Coffee {// 获取咖啡名public abstract String getName();// 加糖public void addSugar(){System.out.println("加糖");}// 加奶public void addMilk(){System.out.println("加奶");}
}

美式咖啡类

public class AmericanCoffee extends Coffee {@Overridepublic String getName() {return "美式咖啡";}
}

拿铁咖啡类

public class LatteCoffee extends Coffee {@Overridepublic String getName() {return "拿铁咖啡";}
}

咖啡店类

public class CoffeeStore {public Coffee orderCoffee(String type) {// 根据类型创建咖啡实例Coffee coffee = null;if("Latte".equals(type)) {coffee = new LatteCoffee();}else if("Americano".equals(type)) {coffee = new AmericanCoffee();}else {System.out.println("Sorry, we don't have this kind of coffee.");}// 加糖和奶coffee.addSugar();coffee.addMilk();return coffee;}
}

测试

public class Client {public static void main(String[] args) {// 1 创建咖啡店类CoffeeStore coffeeStore = new CoffeeStore();// 2 点咖啡Coffee coffee = coffeeStore.orderCoffee("Latte");System.out.println(coffee.getName());}
}

在Java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new，就会对该对象耦合严重，假如需要更换对象，所有new的地方都需要修改一遍，这显然违背了开闭原则。如果使用工厂来生产对象，就只需要和工厂打交道就好了，彻底和对象解耦，如果需要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的。所以说，工厂模式的最大优点就是：解耦。

三种工厂：

• 简单工厂模式（不属于GOF的23种经典设计模式）
• 工厂方法模式
• 抽象工厂模式
  

简单工厂模式

简单工厂不是一种设计模式，反而比较像是一种编程习惯。

结构

简单工厂包含以下角色：

• 抽象产品：定义了产品的规范，描述了产品的主要特征和功能（通用行为）
• 具体产品：实现或继承抽象产品（接口/抽象类）的子类
• 具体工厂：提供了创建产品的方法，调用者通过该方法来获取产品（根据传递的不同参数来创建不同的产品示例）
  

实现

咖啡类:

public abstract class Coffee {// 获取咖啡名public abstract String getName();// 加糖public void addSugar(){System.out.println("加糖");}// 加奶public void addMilk(){System.out.println("加奶");}
}

美式咖啡类：

public class AmericanCoffee extends Coffee {@Overridepublic String getName() {return "美式咖啡";}
}

拿铁咖啡类：

public class LatteCoffee extends Coffee {@Overridepublic String getName() {return "拿铁咖啡";}
}

简单咖啡工厂类：

public class SimpleCoffeeFactory {public Coffee createCoffee(String type) {// 根据类型创建咖啡实例Coffee coffee = null;if("Latte".equals(type)) {coffee = new LatteCoffee();}else if("Americano".equals(type)) {coffee = new AmericanCoffee();}else {System.out.println("Sorry, we don't have this kind of coffee.");}return coffee;}
}

咖啡店类：

public class CoffeeStore {public Coffee orderCoffee(String type) {// 实例化工厂SimpleCoffeeFactory simpleCoffeeFactory = new SimpleCoffeeFactory();// 调用生产咖啡的方法Coffee coffee = simpleCoffeeFactory.createCoffee(type);// 加糖和奶coffee.addSugar();coffee.addMilk();return coffee;}
}

测试：

public class Cilent {public static void main(String[] args) {// 创建咖啡店类对象CoffeeStore coffeeStore = new CoffeeStore();// 点咖啡Coffee coffee = coffeeStore.orderCoffee("Latte");System.out.println(coffee.getName());}
}

总结

工厂（factory）处理创建对象的细节，一旦有了SimpleCoffeeFactory，CoffeeStore类中的orderCoffee()就变成此对象的客户，后期如果需要Coffee对象直接从工厂中获取即可。这样就解除了CoffeeStore和Coffee实现类的耦合，同时又产生了新的耦合，CoffeeStore和SimpleCoffeeFactory的耦合，工厂对象和商品对象的耦合。
后期如果需要增加新咖啡，势必需要修改SimpleCoffeeFactory的代码，违反了开闭原则。工厂的客户端可能有很多，如创建美团外卖等，这样只需要修改工厂类的代码，省去了其他的操作。

简单工厂简化了客户端操作，客户端可以调用工厂方法来获取具体的产品，而无需直接与具体产品类交互，降低了耦合，但是有一个很大的问题就是不够灵活，如果需要添加新产品，就需要修改工厂类的代码。

优点：

• 封装了创建对象的过程，可以通过参数直接获取对象
• 把对象的创建和业务逻辑层分开，避免了修改客户端的代码，如果要实现新产品直接修改工厂类，不需要在原代码中修改，降低客户代码修改的可能性，更容易扩展

缺点：

• 增加新产品时需要修改工厂类的代码，违背了开闭原则
  

扩展（静态工厂）

在实际开发中，一部分开发人员将工厂类中创建对象的功能定义成静态的，这就是静态工厂模式，也不属于23种设计模式，是一种编程习惯。
好处就是客户端可以不用实例化工厂对象，直接调用即可。

public class SimpleCoffeeFactory {public static Coffee createCoffee(String type) {// 根据类型创建咖啡实例Coffee coffee = null;if("Latte".equals(type)) {coffee = new LatteCoffee();}else if("Americano".equals(type)) {coffee = new AmericanCoffee();}else {System.out.println("Sorry, we don't have this kind of coffee.");}return coffee;}
}