什么是抽象工厂模式？

### 抽象工厂模式 **定义**：抽象工厂模式是一种创建型设计模式，提供一个接口用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。它允许将具体产品的创建延迟到子类中。 ### 结构 1. **抽象工厂**：定义创建产品对象的接口。 2. **具体工厂**：实现抽象工厂接口，负责生成具体产品的实例。 3. **抽象产品**：定义产品的接口。 4. **具体产品**：实现抽象产品接口，定义具体的产品。 ### 示例 假设我们有一个图形用户界面（GUI）库，其中包括按钮和文本框。 #### 抽象产品 ```java interface Button { void paint(); } interface TextBox { void render(); } ``` #### 具体产品 ```java class WindowsButton implements Button { public void paint() { System.out.println("Rendering a button in Windows style."); } } class MacOSButton implements Button { public void paint() { System.out.println("Rendering a button in MacOS style."); } } class WindowsTextBox implements TextBox { public void render() { System.out.println("Rendering a text box in Windows style."); } } class MacOSTextBox implements TextBox { public void render() { System.out.println("Rendering a text box in MacOS style."); } } ``` #### 抽象工厂 ```java interface GUIFactory { Button createButton(); TextBox createTextBox(); } ``` #### 具体工厂 ```java class WindowsFactory implements GUIFactory { public Button createButton() { return new WindowsButton(); } public TextBox createTextBox() { return new WindowsTextBox(); } } class MacOSFactory implements GUIFactory { public Button createButton() { return new MacOSButton(); } public TextBox createTextBox() { return new MacOSTextBox(); } } ``` #### 应用程序 ```java class Application { private Button button; private TextBox textBox; public Application(GUIFactory factory) { button = factory.createButton(); textBox = factory.createTextBox(); } public void render() { button.paint(); // 具体工厂决定了这里的实现 textBox.render(); } } ``` ### 使用示例 1. **创建 Windows 界面**： ```java GUIFactory factory = new WindowsFactory(); Application app = new Application(factory); app.render(); // 调用 WindowsButton 的 paint 方法 ``` 2. **创建 MacOS 界面**： ```java GUIFactory factory = new MacOSFactory(); Application app = new Application(factory); app.render(); // 调用 MacOSButton 的 paint 方法 ``` ### 总结 在抽象工厂模式中，具体的工厂（`WindowsFactory` 或 `MacOSFactory`）是在创建 `Application` 实例时指定的，因此调用 `button.paint()` 的具体实现取决于传入的工厂。这种方式使得应用程序可以独立于具体的产品类，从而提高了代码的可扩展性和灵活性。

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供一个接口，用于创建相关或依赖对象的家族，而无需明确指定具体类。通过使用抽象工厂模式，可以将产品类的实现从客户端代码中分离出来，使得代码更加灵活和易于扩展。 ### 结构 1. **抽象工厂（Abstract Factory）**：声明一组创建产品的方法。 2. **具体工厂（Concrete Factory）**：实现创建产品的方法，生成具体的产品。 3. **抽象产品（Abstract Product）**：为每种产品声明一个接口。 4. **具体产品（Concrete Product）**：实现抽象产品接口。 ### 示例代码 #### 抽象产品接口 ```java // 抽象产品接口：饮品 public interface Drink { void drink(); } // 抽象产品接口：甜品 public interface Dessert { void eat(); } ``` #### 具体产品实现 ```java // 具体产品：咖啡 public class Coffee implements Drink { @Override public void drink() { System.out.println("Drinking Coffee"); } } // 具体产品：啤酒 public class Beer implements Drink { @Override public void drink() { System.out.println("Drinking Beer"); } } // 具体产品：蛋糕 public class Cake implements Dessert { @Override public void eat() { System.out.println("Eating Cake"); } } // 具体产品：饼干 public class Cookie implements Dessert { @Override public void eat() { System.out.println("Eating Cookie"); } } ``` #### 抽象工厂接口 ```java // 抽象工厂接口 public interface CafeFactory { Drink createDrink(); Dessert createDessert(); } ``` #### 具体工厂实现 ```java // 具体工厂：咖啡工厂 public class CoffeeFactory implements CafeFactory { @Override public Drink createDrink() { return new Coffee(); } @Override public Dessert createDessert() { return new Cake(); } } // 具体工厂：啤酒工厂 public class BeerFactory implements CafeFactory { @Override public Drink createDrink() { return new Beer(); } @Override public Dessert createDessert() { return new Cookie(); } } ``` #### 客户端代码 ```java public class Client { public static void main(String[] args) { CafeFactory coffeeFactory = new CoffeeFactory(); Drink coffee = coffeeFactory.createDrink(); Dessert cake = coffeeFactory.createDessert(); coffee.drink(); cake.eat(); CafeFactory beerFactory = new BeerFactory(); Drink beer = beerFactory.createDrink(); Dessert cookie = beerFactory.createDessert(); beer.drink(); cookie.eat(); } } ``` ### 优点 1. **符合开闭原则**：抽象工厂模式可以很容易地添加新的产品类，而无需修改现有的代码。 2. **代码可扩展性强**：可以通过创建新的具体工厂和产品类来扩展系统。 3. **产品之间的依赖关系**：抽象工厂模式可以确保一系列产品对象之间的关系正确。 ### 缺点 1. **复杂性**：抽象工厂模式会增加系统的复杂性，因为需要定义许多接口和类。 2. **不容易支持新种类的产品**：如果需要添加一个新的产品族，必须修改抽象工厂接口及其所有子类。 ### 适用场景 - 系统需要独立于产品的创建、组合和表示。 - 系统需要配置多个产品系列中的一个产品族。 - 需要提供一个产品类库，且所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。