目录
1.案例分析
【需求】设计一个咖啡店点餐系统。设计一个咖啡类 (Coffee)，并定义其两个子类：美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】；再设计一个咖啡店类 (CoffeeStore)，咖啡店具有点咖啡的功能。具体类的设计如下：
在 Java 中，万物皆对象，这些对象都需要创建，如果创建的时候直接 new 该对象，就会对该对象耦合严重，假如要更换对象，所有 new 对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。如果使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说工厂模式最大的优点就是：解耦。
2.简单工厂模式
简单工厂不是一种设计模式，反而比较像是一种编程习惯。
2.1.结构
简单工厂包含如下角色：
- 抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
- 具体产品：实现或者继承抽象产品的子类。
- 具体工厂：提供了创建产品的方法，调用者通过该方法来获取产品。
2.2.案例实现
现在使用简单工厂对上面案例进行改进，类图如下：
2.2.1.抽象产品
Coffee.java
public abstract class Coffee {
public abstract String getName();
//加糖
public void addSugar(){
System.out.println("加糖");
}
//加奶
public void addMilk(){
System.out.println("加奶");
}
}
2.2.2.具体产品
AmericanCoffee.java
//美式咖啡
public class AmericanCoffee extends Coffee {
@Override
public String getName() {
return "美式咖啡";
}
}
LatteCoffee.java
//拿铁咖啡
public class LatteCoffee extends Coffee {
@Override
public String getName() {
return "拿铁咖啡";
}
}
2.2.3.具体工厂
SimpleCoffeeFactory.java
public class SimpleCoffeeFactory {
public Coffee createCoffee(String type) {
//声明 Coffee 类型的变量，根据不同类型创建不同的 coffee 子类对象
Coffee coffee = null;
if("american".equals(type)) {
coffee = new AmericanCoffee();
} else if("latte".equals(type)) {
coffee = new LatteCoffee();
} else {
throw new RuntimeException("对不起，您所点的咖啡没有");
}
return coffee;
}
}
CoffeeStore.java
public class CoffeeStore {
public Coffee orderCoffee(String type){
SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
//调用生产咖啡的方法
Coffee coffee = factory.createCoffee(type);
//加配料
coffee.addMilk();
coffee.addSugar();
return coffee;
}
}
2.2.4.测试
Clien.java
public class Clien {
public static void main(String[] args) {
// 1.创建咖啡店类
CoffeeStore store = new CoffeeStore();
// 2.点咖啡
Coffee coffee = store.orderCoffee("american");
System.out.println(coffee.getName());
}
}
工厂 (factory) 处理创建对象的细节，一旦有了 SimpleCoffeeFactory，CoffeeStore 类中的 orderCoffee() 就变成此对象的客户，后期如果需要 Coffee 对象直接从工厂中获取即可。这样也就解除了和 Coffee 实现类的耦合，但同时又产生了新的耦合，CoffeeStore 对象和SimpleCoffeeFactory 工厂对象的耦合，工厂对象和商品对象的耦合。后期如果再加新品种的咖啡，我们势必要需求修改SimpleCoffeeFactory 的代码，违反了开闭原则。工厂类的客户端可能有很多，比如创建美团外卖等，这样只需要修改工厂类的代码，省去其他的修改操作。
2.3.优缺点
- 优点：封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展。
- 缺点：增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。
2.4.扩展
静态工厂：在开发中也有一部分人将工厂类中的创建对象的功能定义为静态的，这个就是静态工厂模式，它不是 23 种设计模式中的。代码如下：
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;
}
}
3.✨工厂方法模式
3.1.介绍
工厂方法模式 (Factory Method Pattern) 是一种创建型设计模式，它定义了一个用于创建对象的接口，但将具体的对象创建推迟到子类中进行。在工厂方法模式中，我们通过定义一个抽象工厂类（通常是一个接口），其中包含一个创建对象的抽象方法。具体的对象创建则由实现了抽象工厂类的具体工厂类来完成，每个具体工厂类负责实例化一种具体的对象。这样就将对象的创建和使用分离开来，便于系统的扩展和解耦。
3.1.结构
工厂方法模式的主要角色：
- 抽象工厂 (Abstract Factory)：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
- 具体工厂 (Concrete Factory)：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
- 抽象产品 (Abstract Product)：定义了产品的规范，描述了产品的主要特性和功能。
- 具体产品 (Concrete Product)：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。
3.2.案例实现
使用工厂方法模式对上例进行改进，类图如下：
3.2.1.抽象工厂
CoffeeFactory.java
//抽象工厂，提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品
public interface CoffeeFactory {
//生产咖啡
Coffee createCoffee();
}
3.2.2.具体工厂
AmericanCoffeeFactory.java
//具体工厂：生产美式咖啡
public class AmericanCoffeeFactory implements CoffeeFactory{
@Override
public Coffee createCoffee() {
return new AmericanCoffee();
}
}
LatteCoffeeFactory.java
//具体工厂：生产拿铁咖啡
public class LatteCoffeeFactory implements CoffeeFactory{
@Override
public Coffee createCoffee() {
return new LatteCoffee();
}
}
CoffeeStore.java
//咖啡店
public class CoffeeStore {
//创建咖啡工厂
private CoffeeFactory factory;
public void setFactory(CoffeeFactory factory) {
this.factory = factory;
}
//点咖啡功能
public Coffee orderCoffee() {
Coffee coffee = factory.createCoffee();
//加配料
coffee.addMilk();
coffee.addSugar();
return coffee;
}
}
3.2.3.测试
Client.java
public class Client {
public static void main(String[] args) {
//创建咖啡店对象
CoffeeStore coffeeStore = new CoffeeStore();
//创建具体的咖啡店工厂
CoffeeFactory factory = new AmericanCoffeeFactory();
//CoffeeFactory factory = new LatteCoffeeFactory();
coffeeStore.setFactory(factory);
//点咖啡
Coffee coffee = coffeeStore.orderCoffee();
System.out.println(coffee.getName());
}
}
从以上的编写的代码可以看到，要增加产品类时也要相应地增加工厂类，不需要修改工厂类的代码了，这样就解决了简单工厂模式的缺点。工厂方法模式是简单工厂模式的进一步抽象。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且也克服了其缺点。
3.3.优缺点
（1）优点
- 将对象的创建和使用相分离：工厂方法模式将对象的创建逻辑封装在具体工厂类中，客户端只需通过工厂接口或抽象类来使用产品，无需关心具体的创建过程，从而实现了对象的创建和使用的解耦。
- 可以轻松添加新的产品：由于每个具体工厂类负责实例化一种具体的产品对象，如果需要添加新的产品，只需要添加一个新的具体工厂类即可，不需要修改现有代码，符合开闭原则。
- 灵活性好：工厂方法模式可以根据具体需求选择不同的具体工厂类来创建对象，从而实现不同的行为和逻辑。客户端只需要知道工厂接口或抽象类，无需关心具体的实现细节。
（2）缺点
- 类的个数增加：由于每个具体产品类都需要对应一个具体工厂类，因此如果产品种类较多，会导致具体工厂类的数量增加，增加了系统的复杂性。
- 增加了系统的抽象性和理解难度：相比于简单工厂模式，工厂方法模式引入了抽象工厂类和具体工厂类之间的层级关系，增加了系统的抽象性和理解难度，需要对抽象工厂、具体工厂及其之间的关系有深入的理解。
3.4.应用场景
（1）工厂方法模式适用于以下应用场景：
- 对象的创建需要根据不同的条件或参数进行灵活配置：当对象的创建过程比较复杂，需要根据不同的条件或参数来配置对象的创建逻辑时，可以使用工厂方法模式。每个具体工厂类可以根据不同的条件或参数来创建对应的产品对象。
- 需要扩展或添加新的产品时：当系统需要添加新的产品时，可以通过扩展或添加新的具体工厂类来实现，而无需修改现有的客户端代码。适用于符合开闭原则的情况。
- 隐藏对象创建的细节：当需要将对象的创建细节隐藏起来，只对外提供一个抽象的工厂接口或抽象类时，可以使用工厂方法模式。客户端只需关心抽象工厂和产品接口，无需关心具体的产品创建过程。
- 通过工厂方法进行依赖注入：在依赖注入 (Dependency Injection) 的场景中，可以使用工厂方法模式来创建和注入依赖对象。具体工厂类可以负责创建和管理依赖对象的生命周期，并将创建好的对象注入到需要它的类中。
（2）总而言之，工厂方法模式适用于需要根据不同条件创建不同对象、需要动态添加新产品、隐藏对象创建细节或进行依赖注入的场景。