前言

抽象工厂模式比工厂方法模式的抽象程度更高。在工厂方法模式中每一个具体工厂只需要生成一种具体的产品，但是在抽象工厂模式中每一个具体工厂只可以生产一组相关的具体产品，这样的一组产品称为产品族，产品族中的每一个产品都分属于某一个产品继承等级结构。

一、产品等级结构与产品族

产品等级结构：产品灯具结构即产品的继承结构，例如一个抽象类时电视机，其子类包括海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是其子类。
产品族：在抽象工厂模式中，产品族是指由同一个工厂生产的位于不同产品等级结构中的一组产品，例如海尔电器工厂生产的海尔电视机、海尔冰箱，海尔电视机位于电视机产品等级结构中，海尔冰箱位于冰箱产品的等级结构中，海尔电视机、海尔冰箱构成了一个产品族。

二、抽象工厂模式概述

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。

抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式需要面对多个产品等级结构，一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建。当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时，抽象工厂模式比工厂方法模式更为简单、更有效率。与工厂方法模式相比，抽象工厂模式中的具体工厂不只是创建一种产品，它负责创建一族产品。

三、抽象工厂模式结构与实现

结构

抽象工厂模式包含以下4个角色：

1. AbstractFactory(抽象工厂)：它声明了一组用于创建一族产品的方法，每一个方法对应一种产品。
2. ConcreteFactory(具体工厂)：它实现了在抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中。
3. AbstractProduct(抽象产品)：它为每中产品声明接口，在抽象产品中声明了产品所具有的业务方法。
4. ConcreteProduct(具体产品)：它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法。

实现

抽象工厂中声明了多个工厂方法，用于创建不同类型的产品，抽象工厂可以时接口，也可以时抽象类或者具体类。其典型代码如下：

public interface AbstractFactory(){
	public AbstractProductA createProductA();
	public AbstractProductB createProductB();

具体工厂实现了抽象工厂，每一个具体的工厂方法可以返回一个特定的产品对象，而同一个具体工厂所创建的产品对象构成了一个产品族。对于每一个具体工厂类，其典型代码如下

public class ConcreteFactory1 extends AbstractFactory(){
	//工厂方法一
	public AbstractProudctA createProductA(){
	return new ConcreteProductA1();
	}
	public class ConcreteFactory1 extends AbstractFactory(){
	//工厂方法一
	public AbstractProudctB createProductB(){
	return new ConcreteProductB1();
	}
}

抽象工厂模式应用实例

实例说明

则结构图

在上图中，SkinFactory接口充当抽象工厂，其子类SpringSkinFactory和SummerSkinFactory充当具体工厂，接口Button、TextField和ComboBox充当抽象产品，其子类SpringButton、SpringTextField、SpringComboBox和SummerButton、SummerTextField、SummerComboBox充当具体产品。

抽象工厂模式的缺点

例如上面例子，如果在设计之初因为考虑不全面，忘记为某种类型的界面组件（比如一个单选按钮RadioButton）提供不同皮肤下的风格化显示，那么在往系统中增加单选按钮时将发现非常麻烦，无法在满足开闭原则的前提下增加单选按钮，原因是抽象工厂SkinFactory中根本没有提供创建单选按钮的方法，如果需要增加单选按钮，首先需要修改抽象工厂接口SkinFactory，在其中新增声明创建单选按钮的方法，然后逐个修改具体工厂类，增加相应方法以实现在不同的皮肤库中创建单选按钮此外还需要修改客户端，否则单选按钮无法应用于现有系统。即抽象工厂模式如果要增加新的产品等级结构十分麻烦。

一、工厂方法

工厂方法定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。

1、工厂法法模式结构图：

工厂方法抽象出一个工厂接口，这个接口只有一个方法，就是创建抽象产品的工厂方法，所有要生产具体类的工厂就去实现这个接口。当需要创建新对象的工厂时，就不需要更改原有的工厂类，只需要增加相应的工厂类。

产品抽象类 Product

public abstract class Product {
    protected String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

具体产品类 ConcreteProductA

public class ConcreteProductA extends Product{

    public ConcreteProductA(){
        super();
        this.name = "具体产品 A";
    }
}

具体产品类 ConcreteProductB

public class ConcreteProductB extends Product{

    public ConcreteProductB(){
        super();
        this.name = "具体产品 B";
    }
}

抽象工厂接口 Factory

public interface Factory {
    public Product createProduct();
}

创建 ConcreteProductA 的工厂类 ConcreteProductAFactory

public class ConcreteProductAFactory implements Factory{
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

创建 ConcreteProductB 的工厂类 ConcreteProductBFactory

public class ConcreteProductBFactory implements Factory{
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

效果测试类

public class FactoryMethodTest {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteProductAFactory();
        Factory factoryB = new ConcreteProductBFactory();
        Product productA = factoryA.createProduct();
        Product productB = factoryB.createProduct();

        System.out.println(productA.getName());
        System.out.println(productB.getName());
    }
}

2、工厂方法模式的优缺点

工厂方法模式具有良好的封装性，代码结构清晰。如果一个调用者需要一个具体的产品对象，只要知道这个产品的类名，不用知道创建对象的艰辛过程，降低模块间的耦合，并且拓展性好。但缺点也是相对的，每增加一个产品，就需要加一个产品的工厂类，增加了额外的开发量。

二、抽象工厂模式

抽象工厂模式定义：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

1、抽象工厂模式结构图

AbstractProductA 和 AbstractProductB 是两个抽象产品，而ProductA1和ProductA2、ProductB1、ProductB2就是对两个抽象产品的具体实现。

AbstractFactory是一个抽象工厂接口，它里面包含所有产品创建的抽象方法。而ConcreteFactory1 和ConcreteFactory2就是具体的工厂了。

抽象产品类 AbstractProductA

public abstract class AbstractProductA {
    protected String type = "A型产品";

    protected String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /** 每个产品具体实现该方法 */
    public abstract void doSomething();
}

抽象产品类 AbstractProductB

public abstract class AbstractProductB {
    protected String type = "B型产品";

    protected String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /** 每个产品具体实现该方法 */
    public abstract void doSomething();
}

A型具体产品 ProductA1

public class ProductA1 extends AbstractProductA{

    public ProductA1(){
        super();
        this.name = "产品A1";
    }
    @Override
    public void doSomething() {
        System.out.println(this.name + " doSomething");
    }
}

A型具体产品 ProductA2

public class ProductA2 extends AbstractProductA{

    public ProductA2(){
        super();
        this.name = "产品A2";
    }
    @Override
    public void doSomething() {
        System.out.println(this.name + " doSomething");
    }
}

B型具体产品 ProductB1

public class ProductB1 extends AbstractProductB{

    public ProductB1(){
        super();
        this.name = "产品B1";
    }
    @Override
    public void doSomething() {
        System.out.println(this.name + " doSomething");
    }
}

B型具体产品 ProductB2

public class ProductB2 extends AbstractProductB{

    public ProductB2(){
        super();
        this.name = "产品B2";
    }
    @Override
    public void doSomething() {
        System.out.println(this.name + " doSomething");
    }
}

抽象工厂接口 AbstractFactory

public interface AbstractFactory {

    public AbstractProductA createProductA();

    public AbstractProductB createProductB();
}

创建1系列产品的工厂类 ConcreteFactory1

public class ConcreteFactory1 implements AbstractFactory{
    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}

创建2系列产品的工厂类 ConcreteFactory2

public class ConcreteFactory2 implements AbstractFactory{
    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}

效果测试类

public class AbstractFactoryTest {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory1();

        AbstractProductA productA = factory.createProductA();
        AbstractProductB productB = factory.createProductB();
        productA.doSomething();
        productB.doSomething();

        System.out.println("=========切换产品系列工厂=========");

        factory = new ConcreteFactory2();
        productA = factory.createProductA();
        productB = factory.createProductB();
        productA.doSomething();
        productB.doSomething();
    }

}

输出：
产品A1 doSomething
产品B1 doSomething
=切换产品系列工厂=
产品A2 doSomething
产品B2 doSomething

由此可见，切换工厂类，即可对获取的产品系列进行切换

2、抽象工厂模式的优缺点

抽象工厂最大的好处是便于切换产品系列，其次是它让具体的创建实例过程与客户端分离，客户端是通过抽象接口获取实例，依赖的产品也是抽象的，而不是具体的产品类。

抽象工厂的缺点是产品族的拓展非常困难，如果增加了一个产品，抽象工厂类中需要增加创建该产品的抽象方法，具体工厂类中也得去实现，涉及到的改动多。

前言

本篇博客是关于抽象工厂的实现，若文章中出现相关问题，请指出！

对应代码地址：Gitee（demo-exer/ java-Lear23designpatterns）、Github（java-demo/ java-Lear23designpatterns）

所有博客文件目录索引：博客目录索引(持续更新)

一、认识抽象工厂模式

抽象工厂模式也是工厂模式的一种，相对于简单工厂模式、工厂方法模式考虑的是一类产品的生产，而抽象工厂模式则是考虑多个产品族的创建。在抽象工厂模式中，有一个抽象工厂，该抽象工厂中提供了产生不同抽象产品的方法。其中抽象工厂是可以创建工厂的工厂！

定义：抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口无需指定它们具体的类。

应用场景：

1. 提供一个产品类的工厂，所有的产品以同样的接口出现，使用者不依赖于具体的实现。
2. 强调一些列相关的产品对象(如下面示例的产品族)，一起使用创建对象需要大量重复的代码。

结构：抽象工厂、具体工厂；抽象产品、具体产品。

优缺点：

• 优点：获取具体系列产品只需要通过具体系列工厂获取，无序关心创建的细节；
• 缺点：规定了所有可能被创建的产品集合，若是出现某一个系列出现新的产品就会导致所有的系列都会创建指定的接口！扩展新产品困难，增加了系统的抽象性与复杂度。

引用 C语言中文网—抽象工厂模式图

二、实现抽象工厂模式

2.1、代码实现

在Abstract目录下的是抽象工厂模式代码：

抽象产品：Iphone、Router

//手机接口
public interface Iphone {
    void start();
    void music();
    void ring();
    void stop();
}

//路由器接口
public interface Router {
    void start();
    void stop();
    void work();
}

• 抽象工厂解决的是一个产品族的创建，品牌可以有多个，一个品牌也会生产不同的产品，其不同品牌的相同产品我们就可以将其进行抽象，由于我们注重的并不是一个产品的创建而是一个产品族，所以我们还需要抽象一个品牌接口即相当于是一个抽象工厂，该抽象工厂可以创建具体的工厂(实现其接口)。

抽象工厂：Brand

//品牌接口(可根据不同的品牌获取不同的产品)
public interface Brand {
    Iphone getPhone();
    Router getRouter();
}

具体产品：HuaWeiPhone、LianXiangPhone、HuaWeiRouter、LianXiangRouter

//手机的实现类
//华为牌手机
public class HuaWeiPhone implements Iphone {
    @Override
    public void start() {
        System.out.println("华为手机启动中...");
    }

    @Override
    public void music() {
        System.out.println("华为手机播放音乐中...");
    }

    @Override
    public void ring() {
        System.out.println("华为手机开启闹铃中...");
    }

    @Override
    public void stop() {
        System.out.println("华为手机关机中...");
    }
}

//联想牌手机
public class LianXiangPhone implements Iphone {
    @Override
    public void start() {
        System.out.println("联想手机正在启动...");
    }

    @Override
    public void music() {
        System.out.println("联想手机播放音乐中...");
    }

    @Override
    public void ring() {
        System.out.println("联想手机开启闹铃...");
    }

    @Override
    public void stop() {
        System.out.println("联想手机关机中...");
    }
}

//路由器的实现类
//华为路由器
public class HuaWeiRouter implements Router{
    @Override
    public void start() {
        System.out.println("华为路由器正在启动...");
    }

    @Override
    public void stop() {
        System.out.println("华为路由器正在关机...");
    }

    @Override
    public void work() {
        System.out.println("华为路由器开始工作...");
    }
}

//联想路由器
public class LianXiangRouter implements Router{
    @Override
    public void start() {
        System.out.println("联想路由器正在启动...");
    }

    @Override
    public void stop() {
        System.out.println("联想路由器正在关机...");
    }

    @Override
    public void work() {
        System.out.println("联想路由器开始工作...");
    }
}

具体工厂：既然产品有了，那我们一定是从指定工厂中来获取产品，接着我们通过抽象工厂来创建工厂类：

//华为工厂(提供华为手机、华为路由器)
public class HuaWeiFactory implements Brand{
    @Override
    public Iphone getPhone() {
        return new HuaWeiPhone();
    }

    @Override
    public Router getRouter() {
        return new HuaWeiRouter();
    }
}

//联想工厂(提供联想手机、联想路由器)
public class LianXiangFactory implements Brand{
    @Override
    public Iphone getPhone() {
        return new LianXiangPhone();
    }

    @Override
    public Router getRouter() {
        return new LianXiangRouter();
    }
}

最终我们来创建一个顾客类Customer，获取不同品牌的产品并且使用产品：

public class Customer {

    public static void main(String[] args) {
        //获取华为工厂
        Brand huawei = new HuaWeiFactory();
        Iphone phone = huawei.getPhone();//华为工厂获取华为手机
        phone.start();
        phone.music();
        phone.ring();
        phone.stop();
        Router router = huawei.getRouter();//华为工厂获取华为路由器
        router.start();
        router.work();
        router.stop();
        //----------------------
        System.out.println();
        Brand lianxiang = new LianXiangFactory();
        Iphone phone1 = lianxiang.getPhone();//华为工厂获取华为手机
        phone1.start();
        phone1.music();
        phone1.ring();
        phone1.stop();
        Router router1 = lianxiang.getRouter();//华为工厂获取华为路由器
        router1.start();
        router1.work();
        router1.stop();
    }
}

2.2、分析说明

在上面顾客类中的测试方法里，我们通过不同的工厂来获取到不同品牌的产品，具体的产品进行了代码的隔离，无需关心创建过程中的细节！

我们看下上面整体代码的依赖图：

• 将具体产品类型进行抽象，将具体生产商抽象成一个工厂并提供获取抽象产品的接口。
• 当我们需要具体的产品时只需要通过具体的工厂的方法即可获取，而不用再去管其中的细节。

若是我们要添加其他品牌如小米，我们只需要实现Brand接口创建一个工厂，分别实现其接口即可，符合开闭原则；若是新增一个产品A，那么就需要在Brand中添加获取A的接口，那么其所有实现该接口的工厂类都需要修改，这就不符合开闭原则。

总结

1、抽象工厂由四个部分组成：抽象工厂、具体工厂；抽象产品、具体产品。

2、添加新的产品族时只需要实现抽象工厂接口创建一个工厂并实现其中的方法即可，符合了开闭原则；而对于添加某个新产品则需要添加抽象工厂的接口，即造成所有抽象工厂的实现类都要进行修改，这就违反了开闭原则。

3、针对于抽象工厂模式不可以增加产品，可以增加产品族！(一旦增加产品就会造成大量修改)。

4、对于抽象工厂模式针对于的是产品族！

参考资料

视频：狂神说Java—抽象工厂模式

[1]. 抽象工厂模式（详解版）

我是长路，感谢你的耐心阅读。如有问题请指出，我会积极采纳！
欢迎关注我的公众号【长路Java】，分享Java学习文章及相关资料
Q群：851968786 我们可以一起探讨学习
注明：转载可，需要附带上文章链接