工厂模式（Factory Pattern）

在 Java 编程中，工厂模式（Factory Pattern）是一种创建对象的设计模式。它提供了一种创建对象的方式，允许子类决定实例化哪一个类。工厂模式主要用于将对象的创建逻辑从使用对象的代码中分离出来，这样可以减少系统中的耦合度，提高代码的灵活性和可维护性。

工厂模式有几种常见的变体：简单工厂模式、工厂方法模式和抽象工厂模式。以下是这三种模式的简单介绍和代码示例：

1. 简单工厂模式（Simple Factory Pattern）
简单工厂模式通过一个工厂类来创建对象，而不是直接在客户端代码中实例化对象。工厂类根据传入的信息决定创建哪个类的实例。

示例代码：

java
// 产品接口
interface Product {
    void use();
}

// 具体产品A
class ProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using Product A");
    }
}

// 具体产品B
class ProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using Product B");
    }
}

// 工厂类
class ProductFactory {
    public static Product createProduct(String type) {
        switch (type) {
            case "A":
                return new ProductA();
            case "B":
                return new ProductB();
            default:
                throw new IllegalArgumentException("Unknown product type");
        }
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Product productA = ProductFactory.createProduct("A");
        productA.use();
        
        Product productB = ProductFactory.createProduct("B");
        productB.use();
    }
}
2. 工厂方法模式（Factory Method Pattern）
工厂方法模式定义了一个接口用于创建对象，但让子类决定实例化哪一个类。工厂方法模式将对象的创建推迟到子类中进行。

示例代码：

java
// 产品接口
interface Product {
    void use();
}

// 具体产品A
class ProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using Product A");
    }
}

// 具体产品B
class ProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using Product B");
    }
}

// 工厂接口
interface ProductFactory {
    Product createProduct();
}

// 具体工厂A
class ProductAFactory implements ProductFactory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

// 具体工厂B
class ProductBFactory implements ProductFactory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        ProductFactory factoryA = new ProductAFactory();
        Product productA = factoryA.createProduct();
        productA.use();
        
        ProductFactory factoryB = new ProductBFactory();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}
3. 抽象工厂模式（Abstract Factory Pattern）
抽象工厂模式提供了一个接口，用于创建一系列相关或依赖的对象，而无需指定它们具体的类。它通常用于创建产品族。

示例代码：

// 产品A接口
interface ProductA {
    void use();
}

// 产品B接口
interface ProductB {
    void use();
}

// 具体产品A1
class ProductA1 implements ProductA {
    @Override
    public void use() {
        System.out.println("Using Product A1");
    }
}

// 具体产品A2
class ProductA2 implements ProductA {
    @Override
    public void use() {
        System.out.println("Using Product A2");
    }
}

// 具体产品B1
class ProductB1 implements ProductB {
    @Override
    public void use() {
        System.out.println("Using Product B1");
    }
}

// 具体产品B2
class ProductB2 implements ProductB {
    @Override
    public void use() {
        System.out.println("Using Product B2");
    }
}

// 抽象工厂接口

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

// 具体工厂1

class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}

// 具体工厂2

class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}

// 客户端代码
 

public class Main {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.use();
        productB1.use();
        
        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.use();
        productB2.use();
    }
}