Java工厂模式的三种变体深入解析

Java工厂模式是一种创建对象的设计模式，它将对象的创建过程抽象出来，以便在运行时决定实例化哪个具体的类。它通过将实例化逻辑从客户端代码中分离出来，使得代码更加可维护、灵活和可扩展。工厂模式有三种常见的变体，分别是简单工厂模式、工厂方法模式和抽象工厂模式。下面将对这三种变体进行详细解析，并提供具体的代码示例。

一、简单工厂模式

简单工厂模式（Simple Factory Pattern）又称为静态工厂模式，它是工厂模式的最简单的形式。在简单工厂模式中，我们将创建对象的逻辑放在一个简单的工厂类中，通过调用工厂类的静态方法来创建对象。简单工厂模式适用于创建的对象种类相对较少且不会经常发生变化的情况。

// 抽象产品类
public abstract class Product {
    public abstract void use();
}

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

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

// 简单工厂类
public class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ProductA();
        } else if ("B".equals(type)) {
            return new ProductB();
        } else {
            throw new IllegalArgumentException("Unsupported product type: " + type);
        }
    }
}

// 测试代码
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use(); // Output: Product A is used.

        Product productB = SimpleFactory.createProduct("B");
        productB.use(); // Output: Product B is used.
    }
}

二、工厂方法模式

工厂方法模式（Factory Method Pattern）将实例化逻辑委托给子类来完成，将对象的创建延迟到子类中。每个具体的产品都对应一个具体的工厂，客户端通过调用具体工厂的方法来创建产品。工厂方法模式适用于创建的对象种类较多，且需要灵活扩展的情况。

// 抽象产品类
public abstract class Product {
    public abstract void use();
}

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

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

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

// 具体工厂类A
public class FactoryA extends Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

// 具体工厂类B
public class FactoryB extends Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

// 测试代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new FactoryA();
        Product productA = factoryA.createProduct();
        productA.use(); // Output: Product A is used.

        Factory factoryB = new FactoryB();
        Product productB = factoryB.createProduct();
        productB.use(); // Output: Product B is used.
    }
}

三、抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是工厂方法模式的进一步扩展，在抽象工厂模式中，一个具体的工厂可以创建一系列相关的产品。客户端通过调用具体工厂的方法来创建产品，不同的具体工厂可以创建不同的产品组合。抽象工厂模式适用于需要创建一系列相关的产品，且需要保持一致性的情况。

// 抽象产品类A
public abstract class ProductA {
    public abstract void use();
}

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

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

// 抽象产品类B
public abstract class ProductB {
    public abstract void use();
}

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

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

// 抽象工厂类
public abstract class AbstractFactory {
    public abstract ProductA createProductA();

    public abstract ProductB createProductB();
}

// 具体工厂类1
public class ConcreteFactory1 extends AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

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

// 具体工厂类2
public class ConcreteFactory2 extends AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }

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

// 测试代码
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        productA1.use(); // Output: Product A1 is used.
        ProductB productB1 = factory1.createProductB();
        productB1.use(); // Output: Product B1 is used.

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        productA2.use(); // Output: Product A2 is used.
        ProductB productB2 = factory2.createProductB();
        productB2.use(); // Output: Product B2 is used.
    }
}

通过以上代码示例，可以清楚地看到简单工厂模式、工厂方法模式和抽象工厂模式的具体实现方式及应用场景。在实际开发中，我们可以根据具体的需求来选择适合的工厂模式来创建对象，以达到代码的可维护性、灵活性和可扩展性。