工厂模式（Factory Pattern）

工厂模式（Factory Pattern）是面向对象编程中的一种创建型设计模式，定义了一个接口用于创建对象，但让子类决定实例化哪个类。工厂方法将实例化操作推迟到子类，这使得一个类的实例化过程可以由子类来决定，而不是直接在父类中实现。

工厂模式一般分为三种类型：

1. 简单工厂模式（Simple Factory Pattern）：不是一个标准的 GoF 设计模式，但经常使用。

2. 工厂方法模式（Factory Method Pattern）：定义一个创建对象的接口，但让子类决定实例化哪个类，工厂方法使得实例化推迟到子类。

3. 抽象工厂模式（Abstract Factory Pattern）：提供一个接口用于创建一系列相关或互相依赖的对象，而无需指定它们具体的类。

简单工厂模式

简单工厂模式使用一个单一的工厂类来创建不同类型的对象。它通常用于创建一组相关对象。

示例：

// 产品接口
public interface Product {
    void use();
}
​
// 具体产品A
public class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using Product A");
    }
}
​
// 具体产品B
public class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using Product B");
    }
}
​
// 简单工厂类
public class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        throw new IllegalArgumentException("Unknown product type");
    }
}
​
// 使用简单工厂
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use(); // 输出 "Using Product A"
​
        Product productB = SimpleFactory.createProduct("B");
        productB.use(); // 输出 "Using Product B"
    }
}

工厂方法模式

工厂方法模式定义一个用于创建对象的接口，但由子类决定实例化哪个类。它使一个类的实例化延迟到其子类。

示例：

// 产品接口
public interface Product {
    void use();
}
​
// 具体产品A
public class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using Product A");
    }
}
​
// 具体产品B
public class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using Product B");
    }
}
​
// 抽象工厂接口
public interface Factory {
    Product createProduct();
}
​
// 具体工厂A
public class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}
​
// 具体工厂B
public class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}
​
// 使用工厂方法模式
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.use(); // 输出 "Using Product A"
        
        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.use(); // 输出 "Using Product B"
    }
}

抽象工厂模式

抽象工厂模式提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类。它通常涉及多个工厂类，每个工厂类负责创建一组相关的对象。

示例：

// 产品A接口
public interface ProductA {
    void use();
}
​
// 产品B接口
public interface ProductB {
    void use();
}
​
// 具体产品A1
public class ConcreteProductA1 implements ProductA {
    @Override
    public void use() {
        System.out.println("Using Product A1");
    }
}
​
// 具体产品A2
public class ConcreteProductA2 implements ProductA {
    @Override
    public void use() {
        System.out.println("Using Product A2");
    }
}
​
// 具体产品B1
public class ConcreteProductB1 implements ProductB {
    @Override
    public void use() {
        System.out.println("Using Product B1");
    }
}
​
// 具体产品B2
public class ConcreteProductB2 implements ProductB {
    @Override
    public void use() {
        System.out.println("Using Product B2");
    }
}
​
// 抽象工厂接口
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}
​
// 具体工厂1
public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }
​
    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}
​
// 具体工厂2
public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }
​
    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}
​
// 使用抽象工厂模式
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.use(); // 输出 "Using Product A1"
        productB1.use(); // 输出 "Using Product B1"
        
        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.use(); // 输出 "Using Product A2"
        productB2.use(); // 输出 "Using Product B2"
    }
}

总结

• 简单工厂模式：将实例化逻辑集中在一个工厂类中，通过传入参数来决定创建哪种具体产品。

• 工厂方法模式：通过定义一个创建对象的接口，将实例化延迟到子类，子类负责具体的产品创建。

• 抽象工厂模式：提供一个接口创建一系列相关或互相依赖的对象，每个工厂实例负责创建特定种类的产品对象。

工厂模式的主要优点是使代码结构清晰，易于扩展，符合面向对象设计原则，但在某些情况下可能会增加系统的复杂性。选择使用哪种工厂模式应根据具体需求来决定。