设计模式--抽象工厂（AbstractFactory）

喜欢ヅ旅行 2021-09-30 17:10 229阅读 0赞

# 抽象工厂模式（AbstractFactory） #

工厂方法模式中考虑的是一类产品的生产，如畜牧场只养动物、电视机厂只生产电视机、计算机软件学院只培养计算机软件专业的学生等。  
同种类称为同等级，也就是说：工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类） 的产品，如农场里既养动物又种植物，电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。  
本节要介绍的抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族，图 1 所示的是海尔工厂和 TCL 工厂所生产的电视机与空调对应的关系图。  
![图1 电器工厂的产品等级与产品族][1]

#### 模式的定义与特点 ####

*  **抽象工厂（AbstractFactory）模式的定义：**  
    是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。  
    抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。  
    使用抽象工厂模式一般要满足以下条件:  
    1.系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。  
    2.系统一次只可能消费其中某一族产品，即同族的产品一起使用。
 *  **抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下:**  
    1.可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。  
    2.当增加一个新的产品族时不需要修改原代码，满足开闭原则。
 *  **抽象工厂模式的缺点：**  
    当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。

#### 模式的结构与实现 ####

抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。现在我们来分析其基本结构和实现方法。

*  **模式的结构**  
    抽象工厂模式的主要角色如下。  
    1.**抽象工厂（Abstract Factory）：** 提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。  
    2.**具体工厂（Concrete Factory）：** 主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。  
    3.**抽象产品（Product）：** 定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。  
    4.**具体产品（ConcreteProduct）：** 实现了抽象产品角色所定义的接口，由具体工厂来创建，它 同具体工厂之间是多对一的关系。  
    抽象工厂模式的结构图如图 2 所示。  
    ![图 2  抽象工厂模式的结构图][2]
 *  **模式的实现**  
    从图 2 可以看出抽象工厂模式的结构同工厂方法模式的结构相似，不同的是其产品的种类不止一个，所以创建产品的方法也不止一个。下面给出抽象工厂和具体工厂的代码。

(1) 抽象工厂：提供了产品的生成方法。

interface AbstractFactory
        { 
            public Product1 newProduct1();
            public Product2 newProduct2();
        }

--------------------

(2) 具体工厂：实现了产品的生成方法。

class ConcreteFactory1 implements AbstractFactory
        { 
            public Product1 newProduct1()
            { 
                System.out.println("具体工厂 1 生成-->具体产品 11...");
                return new ConcreteProduct11();
            }
            public Product2 newProduct2()
            { 
                System.out.println("具体工厂 1 生成-->具体产品 21...");
                return new ConcreteProduct21();
            }
        }

#### 模式的实例 ####

我们将创建 Shape 和 Color 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义工厂类 ShapeFactory 和 ColorFactory，这两个工厂类都是扩展了 AbstractFactory。然后创建一个工厂创造器/生成器类 FactoryProducer。  
AbstractFactoryPatternDemo，我们的演示类使用 FactoryProducer 来获取 AbstractFactory 对象。它将向 AbstractFactory 传递形状信息 Shape（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。同时它还向 AbstractFactory 传递颜色信息 Color（RED / GREEN / BLUE），以便获取它所需对象的类型。  
![image][]  
**1.为形状创建一个接口。Shape.java**

public interface Shape { 
       void draw();
    }

--------------------

**2.创建实现接口的实体类。Rectangle.java、Square.java、Circle.java**

public class Rectangle implements Shape { 
     
       @Override
       public void draw() { 
          System.out.println("Inside Rectangle::draw() method.");
       }
    }
    
    public class Square implements Shape { 
     
       @Override
       public void draw() { 
          System.out.println("Inside Square::draw() method.");
       }
    }
    
    public class Circle implements Shape { 
     
       @Override
       public void draw() { 
          System.out.println("Inside Circle::draw() method.");
       }
    }

--------------------

**3.为颜色创建一个接口。Color.java**

public interface Color { 
       void fill();
    }

--------------------

**4.创建实现接口的实体类。Red.java、Green.java、Blue.java**

public class Red implements Color { 
     
       @Override
       public void fill() { 
          System.out.println("Inside Red::fill() method.");
       }
    }
    
    public class Green implements Color { 
     
       @Override
       public void fill() { 
          System.out.println("Inside Green::fill() method.");
       }
    }
    
    public class Blue implements Color { 
     
       @Override
       public void fill() { 
          System.out.println("Inside Blue::fill() method.");
       }
    }

--------------------

**5.为 Color 和 Shape 对象创建抽象类来获取工厂。AbstractFactory.java**

public abstract class AbstractFactory { 
       public abstract Color getColor(String color);
       public abstract Shape getShape(String shape) ;
    }

--------------------

**6.创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象。ShapeFactory.java、ColorFactory.java**

public class ShapeFactory extends AbstractFactory { 
        
       @Override
       public Shape getShape(String shapeType){ 
          if(shapeType == null){ 
             return null;
          }        
          if(shapeType.equalsIgnoreCase("CIRCLE")){ 
             return new Circle();
          } else if(shapeType.equalsIgnoreCase("RECTANGLE")){ 
             return new Rectangle();
          } else if(shapeType.equalsIgnoreCase("SQUARE")){ 
             return new Square();
          }
          return null;
       }
       
       @Override
       public Color getColor(String color) { 
          return null;
       }
    }
    
    public class ColorFactory extends AbstractFactory { 
        
       @Override
       public Shape getShape(String shapeType){ 
          return null;
       }
       
       @Override
       public Color getColor(String color) { 
          if(color == null){ 
             return null;
          }        
          if(color.equalsIgnoreCase("RED")){ 
             return new Red();
          } else if(color.equalsIgnoreCase("GREEN")){ 
             return new Green();
          } else if(color.equalsIgnoreCase("BLUE")){ 
             return new Blue();
          }
          return null;
       }
    }

--------------------

**7.创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂。FactoryProducer.java**

public class FactoryProducer { 
       public static AbstractFactory getFactory(String choice){ 
          if(choice.equalsIgnoreCase("SHAPE")){ 
             return new ShapeFactory();
          } else if(choice.equalsIgnoreCase("COLOR")){ 
             return new ColorFactory();
          }
          return null;
       }
    }

--------------------

**8.使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。AbstractFactoryPatternDemo.java**

public class AbstractFactoryPatternDemo { 
       public static void main(String[] args) { 
     
          //获取形状工厂
          AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
     
          //获取形状为 Circle 的对象
          Shape shape1 = shapeFactory.getShape("CIRCLE");
     
          //调用 Circle 的 draw 方法
          shape1.draw();
     
          //获取形状为 Rectangle 的对象
          Shape shape2 = shapeFactory.getShape("RECTANGLE");
     
          //调用 Rectangle 的 draw 方法
          shape2.draw();
          
          //获取形状为 Square 的对象
          Shape shape3 = shapeFactory.getShape("SQUARE");
     
          //调用 Square 的 draw 方法
          shape3.draw();
     
          //获取颜色工厂
          AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
     
          //获取颜色为 Red 的对象
          Color color1 = colorFactory.getColor("RED");
     
          //调用 Red 的 fill 方法
          color1.fill();
     
          //获取颜色为 Green 的对象
          Color color2 = colorFactory.getColor("Green");
     
          //调用 Green 的 fill 方法
          color2.fill();
     
          //获取颜色为 Blue 的对象
          Color color3 = colorFactory.getColor("BLUE");
     
          //调用 Blue 的 fill 方法
          color3.fill();
       }
    }

--------------------

执行程序，输出结果：

Inside Circle::draw() method.
    Inside Rectangle::draw() method.
    Inside Square::draw() method.
    Inside Red::fill() method.
    Inside Green::fill() method.
    Inside Blue::fill() method.

#### 模式的应用场景 ####

抽象工厂模式最早的应用是用于创建属于不同操作系统的视窗构件。如 java 的 AWT 中的 Button 和 Text 等构件在 Windows 和 UNIX 中的本地实现是不同的。

抽象工厂模式通常适用于以下场景：

1.  当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
2.  系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
3.  系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。

#### 模式的扩展 ####

抽象工厂模式的扩展有一定的“开闭原则”倾斜性：

1.  当增加一个新的产品族时只需增加一个新的具体工厂，不需要修改原代码，满足开闭原则。
2.  当产品族中需要增加一个新种类的产品时，则所有的工厂类都需要进行修改，不满足开闭原则。
3.  当系统中只存在一个等级结构的产品时，抽象工厂模式将退化到工厂方法模式。

[1]: /images/20210812/c18e88dd2e1f4606a2590995f543e388.png
[2]: /images/20210812/65ef3674eaac4988b46cd1817407bf84.png
[image]: /images/20210812/2767afe628b24462b762ca7dddc184fd.png