JAVA编程【设计模式之工厂模式】

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 设计模式中最常用的模式之一，合理选择可以提高代码的可维护性和扩展性。