工厂模式
Java中的工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的最佳方式，而不需要在代码中显式指定所要创建的具体类。工厂模式的主要目的是将对象的创建与使用分离，从而减少类之间的耦合度，并使得软件结构更加灵活、可扩展。
工厂模式的核心思想
- 抽象工厂类：定义一个用于创建对象的接口，但让子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类中进行。
- 具体工厂类：提供具体对象创建的实现，负责实例化产品类。
- 抽象产品类：定义一个产品的接口，是工厂方法所创建的对象的超类型，也就是工厂方法所返回的类型。
- 具体产品类：实现了抽象产品接口的具体类。
工厂模式的类型
工厂模式主要分为三种类型：简单工厂模式（Simple Factory Pattern）、工厂方法模式（Factory Method Pattern）和抽象工厂模式（Abstract Factory Pattern）。
简单工厂模式（Static Factory Method）
简单工厂模式并不属于GoF的23种设计模式之一，但它常被用作引入工厂模式概念的起点。简单工厂模式通过一个工厂类来创建具体的产品实例，通常使用静态方法来实现。
优点：
- 实现了对象的创建和使用的分离。
- 客户端不需要知道具体产品的类名，只需要知道对应的参数即可。
缺点：
- 工厂类集中了所有产品的创建逻辑，违反了高内聚责任分配原则。
- 增加新产品时需要修改工厂类的判断逻辑，违背了开闭原则。
工厂方法模式（Factory Method）
工厂方法模式定义了一个创建对象的接口，但让子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类中进行。
抽象产品类（Product）
public interface Product {
void use();
}具体产品类（ConcreteProductA, ConcreteProductB）
public class ConcreteProductA implements Product {
@Override
public void use() {
System.out.println("Using ConcreteProductA");
}
}
public class ConcreteProductB implements Product {
@Override
public void use() {
System.out.println("Using ConcreteProductB");
}
}抽象工厂类（Creator）
public abstract class Creator {
public abstract Product factoryMethod();
// 模板方法
public void someOperation() {
Product product = factoryMethod();
product.use();
}
}具体工厂类（ConcreteCreatorA, ConcreteCreatorB）
public class ConcreteCreatorA extends Creator {
@Override
public Product factoryMethod() {
return new ConcreteProductA();
}
}
public class ConcreteCreatorB extends Creator {
@Override
public Product factoryMethod() {
return new ConcreteProductB();
}
}客户端代码
public class Client {
public static void main(String[] args) {
Creator creatorA = new ConcreteCreatorA();
creatorA.someOperation(); // 输出: Using ConcreteProductA
Creator creatorB = new ConcreteCreatorB();
creatorB.someOperation(); // 输出: Using ConcreteProductB
}
}优点：
- 用户只需要知道具体工厂类的类型，就可以得到所需要的产品，无须知道具体产品类的类名。
- 符合开闭原则，新增一种产品时，只需要增加相应的具体产品类和具体工厂类即可，原有代码无须修改。
缺点：
- 每增加一个产品，就需要增加一个具体产品类和一个具体工厂类，增加了系统的复杂度。
抽象工厂模式（Abstract Factory）
抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
抽象产品类（AbstractProductA, AbstractProductB）
public interface AbstractProductA {
void use();
}
public interface AbstractProductB {
void anotherMethod();
}具体产品类（ConcreteProductA1, ConcreteProductA2, ConcreteProductB1, ConcreteProductB2）
public class ConcreteProductA1 implements AbstractProductA {
@Override
public void use() {
System.out.println("Using ConcreteProductA1");
}
}
public class ConcreteProductA2 implements AbstractProductA {
@Override
public void use() {
System.out.println("Using ConcreteProductA2");
}
}
// 同理实现 ConcreteProductB1 和 ConcreteProductB2抽象工厂类（AbstractFactory）
public interface AbstractFactory {
AbstractProductA createProductA();
AbstractProductB createProductB();
}具体工厂类（ConcreteFactory1, ConcreteFactory2）
public class ConcreteFactory1 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteProductB1();
}
}
// 同理实现 ConcreteFactory2客户端代码
public class Client {
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactory1();
AbstractProductA productA1 = factory1.createProductA();
productA1.use(); // 输出: Using ConcreteProductA1
AbstractProductB productB1 = factory1.createProductB();
// 假设有 anotherMethod 的实现
// productB1.anotherMethod();
// 可以根据需要使用 ConcreteFactory2 来创建不同的产品族
}
}优点：
- 可以在类的内部对产品族进行约束，保证客户端始终只用到符合当前业务逻辑的产品族。
- 增加了系统的灵活性和可扩展性，新增产品族时，只需要增加相应的具体工厂类和具体产品类即可。
缺点：
- 增加了系统的抽象性和理解难度。
- 客户端需要依赖抽象层，增加了客户端与抽象层之间的耦合。
你对工厂模式了解了吗？
