一、定义与概念

工厂模式（Factory Pattern）是一种创建型设计模式。它提供了一种创建对象的方式，将对象的创建和使用分离。就好像有一个工厂，专门负责生产各种产品（对象），而使用者只需要从工厂获取产品，而不需要关心产品是如何生产出来的。

二、工厂模式的类型

1. 简单工厂模式（Simple Factory Pattern）
   • 结构：
     • 简单工厂模式包含一个工厂类，这个工厂类有一个创建产品对象的方法。产品对象通常有一个共同的抽象父类或者接口。
   • 代码示例（以创建不同形状为例）：

   // 抽象形状类
   interface Shape {
       void draw();
   }
   // 圆形类
   class Circle implements Shape {
       @Override
       public void draw() {
           System.out.println("Drawing a circle");
       }
   }
   // 矩形类
   class Rectangle implements Shape {
       @Override
       public void draw() {
           System.out.println("Drawing a rectangle");
       }
   }
   // 简单工厂类
   class ShapeFactory {
       public static Shape getShape(String shapeType) {
           if (shapeType.equalsIgnoreCase("circle")) {
               return new Circle();
           } else if (shapeType.equalsIgnoreCase("rectangle")) {
               return new Rectangle();
           }
           return null;
       }
   }
   

   • 解释：
     • Shape接口定义了形状的基本行为（这里是draw方法）。Circle和Rectangle类实现了Shape接口，代表具体的形状。ShapeFactory是工厂类，getShape方法根据传入的形状类型字符串来创建相应的形状对象。这种模式的优点是实现简单，将对象的创建逻辑集中在工厂类中。缺点是不符合开闭原则（对扩展开放，对修改关闭），如果要添加新的形状，需要修改工厂类的getShape方法。
2. 工厂方法模式（Factory Method Pattern）
   • 结构：
     • 工厂方法模式在简单工厂模式的基础上，将工厂类的创建方法抽象成抽象方法，由具体的工厂子类来实现创建不同产品的方法。这样每个具体的工厂子类负责创建一种具体的产品。
   • 代码示例（继续以上面形状为例）：

   // 抽象形状类
   interface Shape {
       void draw();
   }
   // 圆形类
   class Circle implements Shape {
       @Override
       public void draw() {
           System.out.println("Drawing a circle");
       }
   }
   // 矩形类
   class Rectangle implements Shape {
       @Override
       public void draw() {
           System.out.println("Drawing a rectangle");
       }
   }
   // 抽象工厂类
   abstract class ShapeFactory {
       abstract Shape createShape();
   }
   // 圆形工厂类
   class CircleFactory extends ShapeFactory {
       @Override
       Shape createShape() {
           return new Circle();
       }
   }
   // 矩形工厂类
   class RectangleFactory extends ShapeFactory {
       @Override
       Shape createShape() {
           return new Rectangle();
       }
   }
   

   • 解释：
     • Shape接口和具体形状类的定义不变。新增了抽象ShapeFactory类，它有一个抽象方法createShape用于创建形状。CircleFactory和RectangleFactory是具体的工厂子类，分别负责创建Circle和Rectangle。这种模式符合开闭原则，当需要添加新的形状时，只需要添加新的形状类和对应的工厂子类，不需要修改原有的代码。但是缺点是工厂子类过多时，代码结构会比较复杂。
3. 抽象工厂模式（Abstract Factory Pattern）
   • 结构：
     • 抽象工厂模式提供一个创建一系列相关产品对象的接口，而不是单个产品对象。客户端调用抽象工厂的抽象创建方法，具体的创建工作由具体的工厂子类来完成，这些子类创建的产品对象是相互关联的。
   • 代码示例（假设创建图形和颜色相关的产品）：

       // 抽象形状类
   interface Shape {
       void draw();
   }
   // 圆形类
   class Circle implements Shape {
       @Override
       public void draw() {
           System.out.println("Drawing a circle");
       }
   }
   // 矩形类
   class Rectangle implements Shape {
       @Override
       public void draw() {
           System.out.println("Drawing a rectangle");
       }
   }
   // 抽象颜色类
   interface Color {
       void fill();
   }
   // 红色类
   class Red implements Color {
       @Override
       public void fill() {
           System.out.println("Filling red");
       }
   }
   // 蓝色类
   class Blue implements Color {
       @Override
       public void fill() {
           System.out.println("Filling blue");
       }
   }
   // 抽象工厂类
   abstract class AbstractFactory {
       abstract Shape createShape();
       abstract Color createColor();
   }
   // 图形颜色工厂1（创建圆形和红色）
   class ShapeColorFactory1 extends AbstractFactory {
       @Override
       Shape createShape() {
           return new Circle();
       }
       @Override
       Color createColor() {
           return new Red();
       }
   }
   // 图形颜色工厂2（创建矩形和蓝色）
   class ShapeColorFactory2 extends AbstractFactory {
       @Override
       Shape createShape() {
           return new Rectangle();
       }
       @Override
       Color createColor() {
           return new Blue();
       }
   }
   

   • 解释：
     • 这里有Shape和Color两个抽象产品系列。Circle、Rectangle是形状产品的具体实现，Red、Blue是颜色产品的具体实现。AbstractFactory是抽象工厂，定义了创建形状和颜色的抽象方法。ShapeColorFactory1和ShapeColorFactory2是具体的工厂子类，分别创建一组相关的产品（如工厂 1 创建圆形和红色，工厂 2 创建矩形和蓝色）。这种模式的优点是代码的可维护性和可扩展性好，适合创建一系列相关的产品对象。缺点是实现复杂，工厂子类的实现比较繁琐。

三、工厂模式的优点

1. 解耦对象的创建和使用：使用者不需要知道对象是如何创建的，只需要关心如何使用对象，降低了代码的耦合度。
2. 提高代码的可维护性和可扩展性：例如在工厂方法模式和抽象工厂模式中，当需要添加新的产品或者产品系列时，可以通过添加新的类而不是修改现有代码来实现。
3. 便于代码的复用：工厂类可以被多个地方复用，创建相同类型的对象。

四、工厂模式的缺点

1. 简单工厂模式不符合开闭原则：当需要添加新的产品时，需要修改工厂类的创建方法，可能会引入错误。
2. 工厂方法模式和抽象工厂模式可能导致代码复杂度过高：尤其是抽象工厂模式，涉及多个抽象产品和具体产品以及它们之间的组合，可能会使代码结构变得复杂，增加了理解和维护的难度。