工厂模式介绍

工厂模式是一种设计模式，它提供了一种创建对象的方式，而不直接暴露对象的创建逻辑。通过使用工厂模式，客户端代码可以从具体类的实例化中解耦，只需关心所需对象的接口或抽象类。

有三种主要的工厂模式：简单工厂模式、工厂方法模式和抽象工厂模式。

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

在简单工厂模式中，有一个工厂类负责创建其他类的实例。客户端通过工厂类的静态方法或者非静态方法来获取所需对象的实例。

java 复制代码

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

// 产品接口
public interface Product {
    void operation();
}

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

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

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

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

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

在工厂方法模式中，每个具体产品类都有对应的工厂类，客户端通过调用工厂接口或抽象类的方法来获取所需对象的实例。

java 复制代码

// 工厂接口
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. 抽象工厂模式（Abstract Factory Pattern）：

抽象工厂模式提供了一组相关或相互依赖的对象的创建接口，而不指定它们的具体类。客户端通过调用工厂接口或抽象类的方法来创建一组相关的产品。

java 复制代码

// 抽象工厂接口
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

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

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

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

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

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

// 具体产品A1
public class ConcreteProductA1 implements ProductA {
    public void operationA() {
        System.out.println("Product A1 operation");
    }
}

// 具体产品A2
public class ConcreteProductA2 implements ProductA {
    public void operationA() {
        System.out.println("Product A2 operation");
    }
}

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

// 具体产品B1
public class ConcreteProductB1 implements ProductB {
    public void operationB() {
        System.out.println("Product B1 operation");
    }
}

// 具体产品B2
public class ConcreteProductB2 implements ProductB {
    public void operationB() {
        System.out.println("Product B2 operation");
    }
}

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

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        productA2.operationA();
        ProductB productB2 = factory2.createProductB();
        productB2.operationB();
    }
}

工厂模式提供了一种创建对象的灵活方式，使得客户端代码不需要直接依赖具体类，而是依赖于抽象接口或类。这有助于提高代码的可维护性、可扩展性，并且符合面向对象设计原则中的"