java抽象工厂模式

我会带着你远行 2022-05-26 13:53 131阅读 0赞

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

看这篇博客之前，需要有 [**工厂方法模式**][Link 1] 、[**简单工厂模式(可点击)**][Link 2] 知识的铺垫 ，如果你还没有，可以先看下那两篇博客；

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

*  图解抽象工厂模式
 *  产品族、产品结构
 *  讲解图例
 *  优点
 *  缺点
 *  抽象工厂模式 VS 工厂方法模式
 *  代码
 *  扩展：现在需要生产8代车

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

# 图解抽象工厂模式 #

![层楼误少年][70]

**这张图必须看懂了，才能看明白什么是** `抽象工厂模式` ；下面我会讲这张图；

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

# 产品族、产品结构 #

在讲解上面的图之前，需要先知道 `产品族`、`产品结构` 的概念；

*  **产品族**
    
    产品族，主要关注‘`族`’这个字眼，就好理解什么是 `产品族` ；
    
    **举个例子**：一个工厂负责生产轿车的车门，他们家主要生产 宝马x6、x7 以及 奥迪A6、A7的车门；*在这里，宝马的6代、7代就是一个* **产品族**，**可以理解为一系列相关但是型号不一样的产品；**
 *  **产品结构**
    
    上面的例子中，宝马、奥迪的6代、7代，分别有不同的工厂生产；`工厂1` 专门生产6代的车门（包括`宝马`、`奥迪`） ，`工厂2` 专门7代的车门；
    
    这里的 `工厂1`、`工厂2` 就是不同的**产品结构** ；**可以简单的理解为规格不同的产品，这些产品之间没有任何联系,但是在一个工厂里面生产出来的；**

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

# 讲解图例 #

图中的 `抽象产品A`、`抽象产品B` 就是对应着例子中的 宝马、奥迪 ；`具体产品A1`、`具体产品A2`代表 **宝马车** 的6代、7代 ；`具体产品B1`、`具体产品B2`代表 **奥迪车** 的6代、7代 ；

`Factory1` 对应着 只生产 `6代` 的工厂； `Factory2` 对应着 只生产 `7代` 的工厂；

`抽象工厂模式`，是一个产品结构**共用**一个工厂；

我想我可以忍住悲伤 假装生命中没有你

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

# 优点 #

> 继承了工厂方法模式的所有优点，并且克服了工厂方法模式的缺点

*  **扩展 `产品结构` 的时候，多个产品类，只需要写一个工厂类**

当扩展新的产品结构的时候，比如后期我们需要生产8代，**虽然我们8代有奥迪、宝马之分，但是只需要写一个8代的工厂类就好了**，而不需要像工厂方法模式里面的那样，一个产品对应着一个工厂类；

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

# 缺点 #

**抽象如抽象工厂模式，还是有缺点的**， **世间安得双全法 不负如来不负卿**

*  **扩展 `产品族` 很费劲**
    
    因为在抽象工厂的时候，我们在工厂里面抽象出的方法，是根据产品族的个数来的，有一个产品就有一个方法对应着，假如我们后期，增加产品族，那么就需要改动工厂接口，这样下面的所有的实现这个接口的类，都需要改动，这将boom；
    
    **看清楚了，是扩展 `产品族` 费劲，而扩展 `产品结构` 很容易 ；**

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

# 抽象工厂模式 VS 工厂方法模式 #

`抽象工厂模式` 更加抽象，跟具有一般性了；在**代码上的体现，就是在产品接口下面，继续抽象出不同的产品族；**

`抽象工厂模式` 里面的工厂生产的是一个**产品结构**的产品，而不是**单一**的产品 ；

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

# 代码 #

产品组接口：

/** * 抽象类，抽象出产品族 宝马、奥迪 */
    abstract class Baoma implements Produce{
    
    }
    
    abstract class Aodi implements Produce{
    
    }

产品实现类：

/** * 具体的实现类 */
    class Baoma6 extends Baoma {
    
        @Override
        public void method() {
            System.out.println("我是宝马X6");
        }
    }
    
    class Baoma7 extends Baoma{
    
        @Override
        public void method() {
            System.out.println("我是宝马X7");
        }
    }
    
    class Aodi6 extends Aodi{
    
        @Override
        public void method() {
            System.out.println("我是奥迪A6");
        }
    }
    
    class Aodi7 extends Aodi{
    
        @Override
        public void method() {
            System.out.println("我是奥迪A7");
        }
    }

工厂接口：

interface Factory {
        /** * 生产宝马 * * @return */
        Produce getBaome();
    
        /** * 生产奥迪 * * @return */
        Produce getAodi();
    }

具体工厂：

/** * 具体的产品结构 */
     class Factory1 implements Factor{ 
    
        @Override
        public Produce getBaome() {
            return new Baoma6();
        }
    
        @Override
        public Produce getAodi() {
            return new Aodi6();
        }
    }
    
     class Factory2 implements Factor{ 
    
         @Override
         public Produce getBaome() {
             return new Baoma7();
         }
    
         @Override
         public Produce getAodi() {
             return new Aodi7();
         }
     }

客户端：

@Test
        public void test() {
    // 生产宝马X6、奥迪A6
            Factor factor1 = new Factory1();
            Produce produce1 = factor1.getBaome();
            produce1.method();
            Produce produce2 = factor1.getAodi();
            produce2.method();
    
            // 生产宝马X7、奥迪A7
            Factor factor2 = new Factory2();
            Produce produce3 = factor2.getBaome();
            produce3.method();
            Produce produce4 = factor2.getAodi();
            produce4.method();
    
        }
    
    -----------------------------------------
    // output:
    // 我是宝马X6
    // 我是奥迪A6
    // 我是宝马X7
    // 我是奥迪A7

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

# 扩展：现在需要生产8代车 #

扩展的产品类：

/** * 扩展的产品类 */
    class Baoma8 extends Baoma{
    
        @Override
        public void method() {
            System.out.println("我是宝马X8");
        }
    }
    
    class Aodi8 extends Aodi{
    
        @Override
        public void method() {
            System.out.println("我是奥迪A8");
        }
    }

扩展的工厂：

/** * 工厂类，扩展的多个产品类，只需要一个扩展一个工厂 */
    class Factory3 implements Factor{
    
        @Override
        public Produce getBaome() {
            return new Baoma8();
        }
    
        @Override
        public Produce getAodi() {
            return new Aodi8();
        }
    }

测试：

// 生产宝马X8、奥迪A8
     Factor factor3 = new Factory3();
     Produce produce5 = factor3.getBaome();
     produce5.method();
     Produce produce6 = factor3.getAodi();
     produce6.method(); ------------------------
    // output
    // 我是宝马X8
    // 我是奥迪A8

从代码中，我们也可以发现扩展产品结构很容易 ；

[Link 1]: https://blog.csdn.net/youngyouth/article/details/80172711
[Link 2]: https://blog.csdn.net/youngyouth/article/details/80171483
[70]: /images/20220526/5e3eced2ef0342a1a7fc642b890eb83f.png