抽象工厂模式

抽象工厂模式定义

抽象工厂模式（Abstract Factory Pattern），属于对象创建型模式。提供一个创建一系列相关或相互依赖（即一族）对象的接口，不需要指定它们具体的类。

产品族小解

上图中Phone和Computer属于不同的产品等级结构，即产品的继承结构。如一个抽象的手机，子类可以是苹果手机、联想手机、小米手机，这样抽象的手机和具体品牌的手机之间构成了一个产品等级结构，抽象手机作为父类，品牌手机作为子类。电脑的产品等级结构也是如此。

而上图中指出的产品族，简单理解就是产品的家族。即由一个工厂生产的位于不同产品等级结构中的一组产品。上图中iPhone是手机产品等级结构、MacBook是电脑产品等级结构，但都是苹果公司一族的。

抽象工厂模式适用环境

1.当系统提供的工厂需生产的具体产品并不是一个简单的对象，而是多个位于不同产品等级结构中属于不同类型的具体产品时。简而言之，抽象工厂模式需要面对的是多个产品等级结构，而工厂方法模式针对的是一个产品等级结构。

UML类图解释

ProductA_Phone：产品A接口
ProductB_Computer ：产品B接口
ConcreteProductA1_Iphone： 具体A类产品A1（实现产品A接口）
ConcreteProductA2_Lenove： 具体A类产品A2（实现产品A接口）
ConcreteProductA3_Xiaomi： 具体A类产品A3（实现产品A接口）
ConcreteProductB1_MacBook： 具体B类产品B1（实现产品B接口）
ConcreteProductB2_ThinkPad： 具体B类产品B2（实现产品B接口）
ConcreteProductB3_XiaomiAir ：具体B类产品B3（实现产品B接口）
Factory ：工厂接口
Factory1_Apple ：具体Apple族工厂
Factory2_Lenove： 具体Lenove族工厂
Factory3_Xiaomi ：具体Xiaomi族工厂

样例代码

package com.sedion.mynawang.Chapter02_AbstractFactoryPattern;

import java.util.logging.Logger;

/**
 * 产品A 手机类 苹果家族 ==> 苹果手机
 * @auther mynawang
 * @create 2016-12-29 10:41
 */
public class ConcreteProductA1_Iphone implements ProductA_Phone{

    private Logger logger =  Logger.getLogger("ConcreteProductA1_Iphone_Log");

    public ConcreteProductA1_Iphone() {
        logger.info("抽象工厂 ==> 苹果手机被创建ConcreteProductA1_Iphone");
    }
}

　　

package com.sedion.mynawang.Chapter02_AbstractFactoryPattern;

import java.util.logging.Logger;

/**
 * 产品A 手机类 联想家族 ==> 联想手机
 * @auther mynawang
 * @create 2016-12-29 10:41
 */
public class ConcreteProductA2_Lenove implements ProductA_Phone{

    private Logger logger =  Logger.getLogger("ConcreteProductA2_Lenove_Log");

    public ConcreteProductA2_Lenove() {
        logger.info("抽象工厂 ==> 联想手机被创建ConcreteProductA2_Lenove");
    }
}

　　

package com.sedion.mynawang.Chapter02_AbstractFactoryPattern;

import java.util.logging.Logger;

/**
 * 产品A 手机类 小米家族 ==> 小米手机
 * @auther mynawang
 * @create 2016-12-29 10:41
 */
public class ConcreteProductA3_Xiaomi implements ProductA_Phone{

    private Logger logger =  Logger.getLogger("ConcreteProductA3_Xiaomi_Log");

    public ConcreteProductA3_Xiaomi() {
        logger.info("抽象工厂 ==> 小米手机被创建ConcreteProductA3_Xiaomi");
    }
}

　　

package com.sedion.mynawang.Chapter02_AbstractFactoryPattern;

import java.util.logging.Logger;

/**
 * 产品B 电脑类 苹果家族 ==> 苹果电脑
 * @auther mynawang
 * @create 2016-12-29 10:42
 */
public class ConcreteProductB1_MacBook implements ProductB_Computer {

    private Logger logger =  Logger.getLogger("ConcreteProductB1_MacBook_Log");

    public ConcreteProductB1_MacBook() {
        logger.info("抽象工厂 ==> 苹果电脑被创建ConcreteProductB1_MacBook");
    }
}

　　

package com.sedion.mynawang.Chapter02_AbstractFactoryPattern;

import java.util.logging.Logger;

/**
 * 产品B 电脑类 联想家族 ==> 联想电脑
 * @auther mynawang
 * @create 2016-12-29 10:42
 */
public class ConcreteProductB2_ThinkPad implements ProductB_Computer {

    private Logger logger =  Logger.getLogger("ConcreteProductB2_ThinkPad_Log");

    public ConcreteProductB2_ThinkPad() {
        logger.info("抽象工厂 ==> 联想电脑ThinkPad被创建ConcreteProductB2_ThinkPad");
    }
}

　　

package com.sedion.mynawang.Chapter02_AbstractFactoryPattern;

import java.util.logging.Logger;

/**
 * 产品B 电脑类 小米家族 ==> 小米电脑
 * @auther mynawang
 * @create 2016-12-29 10:42
 */
public class ConcreteProductB3_XiaomiAir implements ProductB_Computer {

    private Logger logger =  Logger.getLogger("ConcreteProductB3_XiaomiAir_Log");

    public ConcreteProductB3_XiaomiAir() {
        logger.info("抽象工厂 ==> 小米笔记本Air被创建ConcreteProductB3_XiaomiAir");
    }

}

　　

package com.sedion.mynawang.Chapter02_AbstractFactoryPattern;

/**
 * 抽象工厂（一组用于创建一族产品的方法，一个方法对应一类产品）
 * @auther mynawang
 * @create 2016-12-29 10:43
 */
public interface Factory {

    ProductA_Phone createProductA();

    ProductB_Computer createProductB();
}

　　

package com.sedion.mynawang.Chapter02_AbstractFactoryPattern;

/**
 * 具体工厂（苹果公司工厂，用于生产苹果家族的产品）
 * @auther mynawang
 * @create 2016-12-29 10:43
 */
public class Factory1_Apple implements Factory{


    @Override
    public ProductA_Phone createProductA() {
        return new ConcreteProductA1_Iphone();
    }

    @Override
    public ProductB_Computer createProductB() {
        return new ConcreteProductB1_MacBook();
    }
}

　　

package com.sedion.mynawang.Chapter02_AbstractFactoryPattern;

/**
 * 具体工厂（联想公司工厂，用于生产联想家族的产品）
 * @auther mynawang
 * @create 2016-12-29 10:44
 */
public class Factory2_Lenove implements Factory {
    @Override
    public ProductA_Phone createProductA() {
        return new ConcreteProductA2_Lenove();
    }

    @Override
    public ProductB_Computer createProductB() {
        return new ConcreteProductB2_ThinkPad();
    }
}

　　

package com.sedion.mynawang.Chapter02_AbstractFactoryPattern;

/**
 * 具体工厂（小米公司工厂，用于生产小米家族的产品）
 * @auther mynawang
 * @create 2016-12-29 10:44
 */
public class Factory3_Xiaomi implements Factory {
    @Override
    public ProductA_Phone createProductA() {
        return new ConcreteProductA3_Xiaomi();
    }

    @Override
    public ProductB_Computer createProductB() {
        return new ConcreteProductB3_XiaomiAir();
    }
}

　　

package com.sedion.mynawang.Chapter02_AbstractFactoryPattern;

/**
 * 产品A（一类产品 手机）接口
 * @auther mynawang
 * @create 2016-12-29 10:39
 */
public interface ProductA_Phone {
}

　　

package com.sedion.mynawang.Chapter02_AbstractFactoryPattern;

/**
 * 产品B（一类产品 电脑）接口
 * @auther mynawang
 * @create 2016-12-29 10:39
 */
public interface ProductB_Computer {
}

　　

package com.sedion.mynawang;

import com.sedion.mynawang.Chapter02_AbstractFactoryPattern.*;

/**
 * 抽象工厂模式测试
 * @auther mynawang
 * @create 2016-12-29 11:02
 */
public class Chapter02_AbstractFactoryPattern_test {

    public static void main(String[] args) {
        Factory factory1 = new Factory1_Apple();
        factory1.createProductA();
        factory1.createProductB();

        Factory factory2 = new Factory2_Lenove();
        factory2.createProductA();
        factory2.createProductB();

        Factory factory3 = new Factory3_Xiaomi();
        factory3.createProductA();
        factory3.createProductB();
    }
}

　　

// 打印结果

Connected to the target VM, address: '127.0.0.1:54302', transport: 'socket'
十二月 29, 2016 8:36:24 下午 com.sedion.mynawang.Chapter02_AbstractFactoryPattern.ConcreteProductA1_Iphone <init>
信息: 抽象工厂 ==> 苹果手机被创建ConcreteProductA1_Iphone
十二月 29, 2016 8:36:24 下午 com.sedion.mynawang.Chapter02_AbstractFactoryPattern.ConcreteProductB1_MacBook <init>
信息: 抽象工厂 ==> 苹果电脑被创建ConcreteProductB1_MacBook
十二月 29, 2016 8:36:24 下午 com.sedion.mynawang.Chapter02_AbstractFactoryPattern.ConcreteProductA2_Lenove <init>
信息: 抽象工厂 ==> 联想手机被创建ConcreteProductA2_Lenove
十二月 29, 2016 8:36:24 下午 com.sedion.mynawang.Chapter02_AbstractFactoryPattern.ConcreteProductB2_ThinkPad <init>
Disconnected from the target VM, address: '127.0.0.1:54302', transport: 'socket'
信息: 抽象工厂 ==> 联想电脑ThinkPad被创建ConcreteProductB2_ThinkPad
十二月 29, 2016 8:36:24 下午 com.sedion.mynawang.Chapter02_AbstractFactoryPattern.ConcreteProductA3_Xiaomi <init>
信息: 抽象工厂 ==> 小米手机被创建ConcreteProductA3_Xiaomi
十二月 29, 2016 8:36:24 下午 com.sedion.mynawang.Chapter02_AbstractFactoryPattern.ConcreteProductB3_XiaomiAir <init>
信息: 抽象工厂 ==> 小米笔记本Air被创建ConcreteProductB3_XiaomiAir

Process finished with exit code 0

　　

抽象工厂模式优点

1.增加新的具体工厂和产品族很方便，无需修改功能，只要新加相应的产品族即可，符合“开闭原则”。

2.所有具体工厂都实现了抽象工厂中定义的公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。

抽象工厂模式缺点

当增加新的产品等级结构（产品种类）时很麻烦，需要调整抽象类以及所有的具体实现类，会带来很大的不便。具有开闭原则的倾斜性。

抽象工厂模式应用

java.util.Calendar#getInstance()
java.util.Arrays#asList()
java.sql.DriverManager#getConnection()
java.sql.Connection#createStatement()
java.sql.Statement#executeQuery()

样例代码访问地址：https://github.com/mynawang/Design-Pattern-Learning/tree/master/src/main/java/com/sedion/mynawang/Chapter02_AbstractFactoryPattern

博主自白

    本人20有余，天资愚钝，深信勤能补拙。酷爱编程，爱钻研，广交码友，耕于三线，日以继夜而使飞燕之身蜕变为大腹便便。

有志之士点击链接加入技术交流群【专注的程序猿】282087535

    文章如果对你有所帮助是我的荣幸，不妥之处希望指正，转帖请注明本文出自钰火的小栈（http://www.mynawang.com/），请尊重他人的辛勤劳动成果，谢谢！