Java 设计模式之工厂模式教程
工厂模式（Factory Pattern）是一种创建对象的设计模式，它通过隐藏实例化逻辑，使代码更加松耦合、易维护。工厂模式属于创建型设计模式 ，主要用于解耦对象的创建过程。
1. 工厂模式简介
为什么使用工厂模式？
在 Java 代码中，如果使用 new 关键字直接创建对象，代码的可维护性和扩展性会变差。例如：
java
public class Client {
public static void main(String[] args) {
Product product = new ConcreteProduct(); // 直接实例化，违背开闭原则
product.use();
}
}如果有多个 Product 子类，每次都要修改 Client 代码，违背 开闭原则（OCP，Open-Closed Principle），此时可以使用 工厂模式 解决。
2. 工厂模式的三种实现
简单工厂模式（Simple Factory Pattern）
工厂方法模式（Factory Method Pattern）
抽象工厂模式（Abstract Factory Pattern）
3. 简单工厂模式
定义
简单工厂模式由一个工厂类 Factory 负责创建所有产品对象，客户端通过调用工厂方法获取对象，而不需要关心对象创建的具体逻辑。
结构
Product（抽象产品）：定义产品的抽象方法
ConcreteProductA / ConcreteProductB（具体产品）：实现产品
Factory（工厂类）：创建产品对象
代码实现
java
// 1. 抽象产品
interface Product {
void use();
}
// 2. 具体产品 A
class ConcreteProductA implements Product {
@Override
public void use() {
System.out.println("使用产品 A");
}
}
// 3. 具体产品 B
class ConcreteProductB implements Product {
@Override
public void use() {
System.out.println("使用产品 B");
}
}
// 4. 简单工厂
class SimpleFactory {
public static Product createProduct(String type) {
if ("A".equals(type)) {
return new ConcreteProductA();
} else if ("B".equals(type)) {
return new ConcreteProductB();
}
throw new IllegalArgumentException("未知产品类型");
}
}
// 5. 客户端
public class SimpleFactoryDemo {
public static void main(String[] args) {
Product product = SimpleFactory.createProduct("A"); // 通过工厂获取对象
product.use();
}
}优缺点
✅ 优点
统一管理对象创建，减少 new 关键字的使用
客户端代码更简洁，解耦对象创建逻辑
❌ 缺点
不符合开闭原则，每当新增 ConcreteProductC，就需要修改 SimpleFactory 代码
适用于产品较少的场景，不适合扩展性要求高的系统
4. 工厂方法模式
定义
工厂方法模式 通过定义抽象工厂接口，每个具体工厂负责创建一种具体产品，从而避免了简单工厂模式中的代码修改问题。
结构
Product（抽象产品）：定义产品的抽象方法
ConcreteProductA / ConcreteProductB（具体产品）：实现产品
Factory（抽象工厂）：定义创建产品的方法
ConcreteFactoryA / ConcreteFactoryB（具体工厂）：实现工厂，创建对应的具体产品
代码实现
java
// 1. 抽象产品
interface Product {
void use();
}
// 2. 具体产品 A
class ConcreteProductA implements Product {
@Override
public void use() {
System.out.println("使用产品 A");
}
}
// 3. 具体产品 B
class ConcreteProductB implements Product {
@Override
public void use() {
System.out.println("使用产品 B");
}
}
// 4. 抽象工厂
interface Factory {
Product createProduct();
}
// 5. 具体工厂 A
class ConcreteFactoryA implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductA();
}
}
// 6. 具体工厂 B
class ConcreteFactoryB implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductB();
}
}
// 7. 客户端
public class FactoryMethodDemo {
public static void main(String[] args) {
Factory factory = new ConcreteFactoryA(); // 使用工厂方法创建对象
Product product = factory.createProduct();
product.use();
}
}优缺点
✅ 优点
遵循开闭原则，新增产品时不需要修改已有工厂
代码更加符合单一职责原则
❌ 缺点
需要创建多个工厂类，增加了代码复杂性
如果产品种类过多，可能导致工厂类数量激增
5. 抽象工厂模式
定义
抽象工厂模式提供一组相关产品的创建，每个具体工厂负责创建不同产品家族的对象，避免了客户端指定工厂和产品的具体类型。
结构
ProductA / ProductB（抽象产品）：定义产品
ConcreteProductA1 / ConcreteProductA2 / ConcreteProductB1 / ConcreteProductB2（具体产品）
Factory（抽象工厂）：定义创建方法
ConcreteFactory1 / ConcreteFactory2（具体工厂）：创建对应产品
代码实现
java
// 1. 抽象产品 A
interface ProductA {
void use();
}
// 2. 抽象产品 B
interface ProductB {
void use();
}
// 3. 具体产品 A1
class ConcreteProductA1 implements ProductA {
@Override
public void use() {
System.out.println("使用产品 A1");
}
}
// 4. 具体产品 B1
class ConcreteProductB1 implements ProductB {
@Override
public void use() {
System.out.println("使用产品 B1");
}
}
// 5. 抽象工厂
interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
// 6. 具体工厂 1
class ConcreteFactory1 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
// 7. 客户端
public class AbstractFactoryDemo {
public static void main(String[] args) {
AbstractFactory factory = new ConcreteFactory1();
ProductA productA = factory.createProductA();
ProductB productB = factory.createProductB();
productA.use();
productB.use();
}
}优缺点
✅ 优点
适用于多个产品族的创建
避免了工厂类泛滥的问题
❌ 缺点
扩展产品族时，必须修改所有工厂，不符合开闭原则
6. 总结
工厂模式是 Java 设计模式中最常用的模式之一，合理选择可以提高代码的可维护性和扩展性。