Java抽象工厂模式案例

• 抽象工厂模式是一种创建型设计模式，它允许你创建一系列相关或相互依赖的对象，而无需指定它们具体的类。
• 首先，我们定义两个产品接口：

public interface ProductA {
    void use();
}
 
public interface ProductB {
    void use();
}

• 接下来，我们创建两个实现这些接口的具体产品类：

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

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

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

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

• 然后，我们创建一个抽象工厂接口，其中包含创建产品的方法：

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

• 现在，我们创建两个实现抽象工厂接口的具体工厂类。每个工厂类负责创建一组相关或相互依赖的产品：

public class Factory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }
 
    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}

public class Factory2 implements 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 Factory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        
        productA1.use();
        productB1.use();
        
        // 创建第二个工厂对象
        AbstractFactory factory2 = new Factory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        
        productA2.use();
        productB2.use();
    }
}

• 运行客户端代码后，您将看到以下输出：

Using Product A1
Using Product B1
Using Product A2
Using Product B2

通过抽象工厂，您可以轻松地创建一组相关或相互依赖的对象，而无需关心具体的实现细节。