java 抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一种方式来封装一组具有共同主题的单个工厂，而不需要指定它们的具体类。在抽象工厂模式中，每个工厂都负责创建一组产品（通常是一系列产品或产品线），这些产品通常相互关联或有某种约束。

在Java中实现抽象工厂模式，你通常会定义以下几个部分：

1. 抽象产品接口（Abstract Product）：定义产品的通用接口或抽象类。

2. 具体产品类（Concrete Product）：实现抽象产品接口的具体产品类。

3. 抽象工厂接口（Abstract Factory）：声明创建抽象产品的工厂方法。

4. 具体工厂类（Concrete Factory）：实现抽象工厂接口，负责创建具体产品。

下面是一个简单的Java代码示例，展示了如何使用抽象工厂模式：

// 抽象产品接口 A  
public interface ProductA {  
    void use();  
}  
  
// 具体产品类 A1  
public class ConcreteProductA1 implements ProductA {  
    @Override  
    public void use() {  
        System.out.println("使用具体产品A1");  
    }  
}  
  
// 具体产品类 A2  
public class ConcreteProductA2 implements ProductA {  
    @Override  
    public void use() {  
        System.out.println("使用具体产品A2");  
    }  
}  
  
// 抽象产品接口 B  
public interface ProductB {  
    void eat();  
}  
  
// 具体产品类 B1  
public class ConcreteProductB1 implements ProductB {  
    @Override  
    public void eat() {  
        System.out.println("使用具体产品B1");  
    }  
}  
  
// 具体产品类 B2  
public class ConcreteProductB2 implements ProductB {  
    @Override  
    public void eat() {  
        System.out.println("使用具体产品B2");  
    }  
}  
  
// 抽象工厂接口  
public interface AbstractFactory {  
    ProductA createProductA();  
    ProductB createProductB();  
}  
  
// 具体工厂类 1  
public class ConcreteFactory1 implements AbstractFactory {  
    @Override  
    public ProductA createProductA() {  
        return new ConcreteProductA1();  
    }  
  
    @Override  
    public ProductB createProductB() {  
        return new ConcreteProductB1();  
    }  
}  
  
// 具体工厂类 2  
public class ConcreteFactory2 implements AbstractFactory {  
    @Override  
    public ProductA createProductA() {  
        return new ConcreteProductA2();  
    }  
  
    @Override  
    public ProductB createProductB() {  
        return new ConcreteProductB2();  
    }  
}  
  
// 客户端代码  
public class Client {  
    public static void main(String[] args) {  
        AbstractFactory factory1 = new ConcreteFactory1();  
        ProductA productA1 = factory1.createProductA();  
        ProductB productB1 = factory1.createProductB();  
        productA1.use();  
        productB1.eat();  
  
        AbstractFactory factory2 = new ConcreteFactory2();  
        ProductA productA2 = factory2.createProductA();  
        ProductB productB2 = factory2.createProductB();  
        productA2.use();  
        productB2.eat();  
    }  
}

在这个例子中，我们有两个抽象产品接口ProductA和ProductB，它们各自有两个具体实现ConcreteProductA1, ConcreteProductA2和ConcreteProductB1, ConcreteProductB2。我们还定义了一个抽象工厂接口AbstractFactory，它声明了创建产品A和产品B的工厂方法。然后，我们有两个具体工厂类ConcreteFactory1和ConcreteFactory2，它们分别负责创建产品A1和产品B1，以及产品A2和产品B2。

客户端代码使用具体工厂来创建具体产品，而不需要了解这些产品的具体实现细节。这种方式使得系统更加灵活，容易扩展和修改，因为你可以在不修改客户端代码的情况下增加新的工厂和产品。