工厂模式（Factory Pattern）

工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。在工厂模式中，创建对象的逻辑被移到了工厂类中，以便在需要时动态实例化一个具体类，从而使客户端代码与被创建的类解耦。

有三种主要的工厂模式：简单工厂模式（Simple Factory Pattern）、工厂方法模式（Factory Method Pattern）和抽象工厂模式（Abstract Factory Pattern）。

简单工厂模式（Simple Factory Pattern）：

在简单工厂模式中，有一个工厂类负责创建对象，而不是在代码中直接使用 new 关键字实例化对象。这种模式适用于创建对象的逻辑较简单的情况。

public class SimpleFactory {
    public Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}

interface Product {
    void doSomething();
}

class ConcreteProductA implements Product {
    public void doSomething() {
        System.out.println("Product A");
    }
}

class ConcreteProductB implements Product {
    public void doSomething() {
        System.out.println("Product B");
    }
}

在这个例子中，SimpleFactory 负责创建不同类型的产品，客户端代码只需要知道产品的类型，而不需要知道具体的实现类。

工厂方法模式（Factory Method Pattern）：

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

public interface Factory {
    Product createProduct();
}

class ConcreteFactoryA implements Factory {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

class ConcreteFactoryB implements Factory {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

在这个模式中，每个具体的工厂类负责创建特定类型的产品。

抽象工厂模式（Abstract Factory Pattern）：

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

interface ProductA {
    void doSomething();
}

interface ProductB {
    void doSomething();
}

class ConcreteFactory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }
    
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

class ConcreteFactory2 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }
    
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

class ConcreteProductA1 implements ProductA {
    public void doSomething() {
        System.out.println("Product A1");
    }
}

class ConcreteProductB1 implements ProductB {
    public void doSomething() {
        System.out.println("Product B1");
    }
}

class ConcreteProductA2 implements ProductA {
    public void doSomething() {
        System.out.println("Product A2");
    }
}

class ConcreteProductB2 implements ProductB {
    public void doSomething() {
        System.out.println("Product B2");
    }
}

在抽象工厂模式中，ConcreteFactory1 和 ConcreteFactory2 分别负责创建产品家族1和产品家族2的产品。这样，客户端代码只需要选择使用哪个工厂，而无需关心具体的产品实现。