引入案例——咖啡店点餐系统：
要求：
设计一个咖啡类（Coffee），并定义其两个子类（美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】）；再设计一个咖啡店类（CoffeeStore），咖啡店具有点咖啡的功能。
先看看没有使用简单工厂模式的实现
UML类图如下：
Code如下：
（1）Main方法
package 简单工场;
public class coffeeTest {
public static void main(String[] args) {
//1.创建咖啡店类
CoffeeStore store = new CoffeeStore();
//2.点咖啡
Coffee coffee = store.orderCoffee("latte");
System.out.println(coffee.getName());
}
}
（2）Coffee类
package 简单工场;
public abstract class Coffee {
public abstract String getName();
//加糖
public void addSugar(){
System.out.println("加糖");
}
//加奶
public void addMilk(){
System.out.println("加奶");
}
}
（3）AmericanCoffee类
package 简单工场;
public class AmericanCoffee extends Coffee{
public String getName(){
return "美式咖啡";
}
}
（4）LatteCoffee类
package 简单工场;
public class LatteCoffee extends Coffee{
public String getName(){
return "拿铁咖啡";
}
}
（5）CoffeeStore类
package 简单工场;
public class CoffeeStore {
public Coffee orderCoffee(String type){
//声明Coffee类型的变量，根据不同类型创建不同的Coffee的子类对象
//初始化
Coffee coffee = null;
if ("amerian".equals(type)){
coffee = new AmericanCoffee();
}else if ("latte".equals(type)){
coffee = new LatteCoffee();
}else {
throw new RuntimeException("对不起，你所点咖啡没有");
}
//加配料
coffee.addMilk();
coffee.addSugar();
return coffee;
}
}
运行如下：
存在问题：
如果要更换一种coffee需要需改main中orderCoffee方法中的参数，这里就两个类，but有很多个类呢？显然这就违背了设计模式七大原则中的开闭原则！
在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。
如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦。
简单工厂模式
简单工厂不是一种设计模式，反而比较像是一种编程习惯。
简单工厂包含如下角色：
- 抽象产品 ：定义了产品的规范，描述了产品的主要特性和功能。
- 具体产品 ：实现或者继承抽象产品的子类
- 具体工厂 ：提供了创建产品的方法，调用者通过该方法来获取产品。
UML类图：
代码如下：
其中coffeeTest类，Coffee类，AmericanCoffee类，LatteCoffee类不用需改。
（1）添加一个类，SimpleCoffeeFactory
package 简单工场;
public class SimpleCoffeeFactory {
public Coffee createCoffee(String type){
Coffee coffee = null;
if ("amerian".equals(type)){
coffee = new AmericanCoffee();
}else if ("latte".equals(type)){
coffee = new LatteCoffee();
}else {
throw new RuntimeException("对不起，你所点咖啡没有");
}
return coffee;
}
}
（2）将上面写的CoffeeStore类修改一下
package 简单工场;
public class CoffeeStore {
public Coffee orderCoffee(String type){
SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
Coffee coffee = factory.createCoffee(type);
coffee.addSugar();
coffee.addMilk();
return coffee;
}
}
显然，这样子使用了SimpleCoffeeFactory类，在创建一个类的时候，就不会再依赖具体的产品对象了!
总结：
工厂（factory）处理创建对象的细节，一旦有了SimpleCoffeeFactory，CoffeeStore类中的orderCoffee()就变成此对象的客户，后期如果需要Coffee对象直接从工厂中获取即可。这样也就解除了和Coffee实现类的耦合，同时又产生了新的耦合，CoffeeStore对象和SimpleCoffeeFactory工厂对象的耦合，工厂对象和商品对象的耦合。
后期如果再加新品种的咖啡，我们势必要需求修改SimpleCoffeeFactory的代码，违反了开闭原则。工厂类的客户端可能有很多，比如创建美团外卖等，这样只需要修改工厂类的代码，省去其他的修改操作。
优点：
封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展。
缺点：
增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。（虽然也是违背了开闭原则，但是比不使用直接创建对象要好得多！）
扩展：
在开发中也有一部分人将工厂类中的创建对象的功能定义为静态的，这个就是静态工厂模式，它也不是23种设计模式中的。代码如下：
只要需改一下SimpleCoffeeFactory即可（加一个static即可）
public class SimpleCoffeeFactory {
public static Coffee createCoffee(String type) {
Coffee coffee = null;
if("americano".equals(type)) {
coffee = new AmericanoCoffee();
} else if("latte".equals(type)) {
coffee = new LatteCoffee();
}
return coffe;
}
}
在CoffeeStore中只要修改一下调用静态方法即可！
Coffee coffee = SimpleCoffeeFactory.createCoffee(type);
package 简单工场;
public class CoffeeStore {
public Coffee orderCoffee(String type){
//修改了这里，不用创建SimpleCoffeeFactory类了
Coffee coffee = SimpleCoffeeFactory.createCoffee(type);
coffee.addSugar();
coffee.addMilk();
return coffee;
}
}