引言

工厂模式（Factory Pattern）是面向对象设计模式中的一种创建型模式，其核心思想是封装对象创建过程，将创建对象的具体实现与使用对象的代码分离。工厂模式可以提高系统的可扩展性和可维护性，降低模块间的耦合度。本文将解析三种经典的工厂模式案例，并探讨其应用技巧。

一、简单工厂模式

1. 案例描述

简单工厂模式是最基础的工厂模式，它只定义一个工厂类，用于创建所有产品类的实例。这种模式适用于产品种类较少且不会经常变化的情况。

2. 代码示例

// 抽象产品类
public interface Product {
    void operation();
}

// 具体产品类A
public class ConcreteProductA implements Product {
    public void operation() {
        System.out.println("具体产品A的操作");
    }
}

// 具体产品类B
public class ConcreteProductB implements Product {
    public void operation() {
        System.out.println("具体产品B的操作");
    }
}

// 简单工厂类
public class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        }
        return null;
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.operation();

        Product productB = SimpleFactory.createProduct("B");
        productB.operation();
    }
}

3. 应用技巧

  • 简单工厂模式适用于产品种类较少且不经常变化的情况。
  • 工厂类需要知道所有具体产品的创建方法，增加了工厂类的复杂度。
  • 不利于扩展，当产品种类增多时，工厂类需要修改。

二、工厂方法模式

1. 案例描述

工厂方法模式定义了一个接口用于创建对象，但允许子类决定实例化哪一个类。这种模式将对象的创建过程推迟到子类中进行。

2. 代码示例

// 抽象产品类
public interface Product {
    void operation();
}

// 具体产品类A
public class ConcreteProductA implements Product {
    public void operation() {
        System.out.println("具体产品A的操作");
    }
}

// 具体产品类B
public class ConcreteProductB implements Product {
    public void operation() {
        System.out.println("具体产品B的操作");
    }
}

// 抽象工厂类
public interface Factory {
    Product createProduct();
}

// 具体工厂类A
public class ConcreteFactoryA implements Factory {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂类B
public class ConcreteFactoryB implements Factory {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.operation();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.operation();
    }
}

3. 应用技巧

  • 工厂方法模式适用于产品种类较多且需要根据不同条件创建不同产品的情况。
  • 工厂类只需要知道如何创建产品，不需要知道具体产品的创建方法。
  • 容易扩展，添加新的产品或工厂类时，只需添加相应的具体类即可。

三、抽象工厂模式

1. 案例描述

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。这种模式适用于产品种类较多，且具有相关性或依赖性。

2. 代码示例

// 抽象产品类
public interface ProductA {
    void operationA();
}

public interface ProductB {
    void operationB();
}

// 具体产品类A1
public class ConcreteProductA1 implements ProductA {
    public void operationA() {
        System.out.println("具体产品A1的操作");
    }
}

// 具体产品类A2
public class ConcreteProductA2 implements ProductA {
    public void operationA() {
        System.out.println("具体产品A2的操作");
    }
}

// 具体产品类B1
public class ConcreteProductB1 implements ProductB {
    public void operationB() {
        System.out.println("具体产品B1的操作");
    }
}

// 具体产品类B2
public class ConcreteProductB2 implements ProductB {
    public void operationB() {
        System.out.println("具体产品B2的操作");
    }
}

// 抽象工厂类
public interface Factory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂类1
public class ConcreteFactory1 implements Factory {
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂类2
public class ConcreteFactory2 implements Factory {
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        productA1.operationA();

        ProductB productB1 = factory1.createProductB();
        productB1.operationB();

        Factory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        productA2.operationA();

        ProductB productB2 = factory2.createProductB();
        productB2.operationB();
    }
}

3. 应用技巧

  • 抽象工厂模式适用于产品种类较多，且具有相关性或依赖性。
  • 工厂类不需要知道具体产品的创建方法，只需提供创建产品的接口。
  • 容易扩展，添加新的产品或工厂类时，只需添加相应的具体类即可。

总结

工厂模式是一种常用的设计模式，能够有效地封装对象创建过程，提高系统的可扩展性和可维护性。本文介绍了三种经典的工厂模式案例，并探讨了其应用技巧。在实际开发中，应根据具体需求选择合适的工厂模式，以提高代码质量。