描述

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

简介

抽象工厂模式类图

每一个模式都是针对一定问题的解决方案。抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则需要面对多个产品等级结构。

产品等级结构与产品族

在工厂方法模式中具体工厂负责生产具体的产品，每一个具体工厂对应一种具体产品，工厂方法具有唯一性，一般情况下，一个具体工厂中只有一个或者一组重载的工厂方法。但是有时候我们希望一个工厂可以提供多个产品对象，而不是单一的产品对象，如一个电器工厂，它可以生产电视机、电冰箱、空调等多种电器，而不是只生产某一种电器。为了更好地理解抽象工厂模式，我们先引入两个概念：

产品等级结构：产品等级结构即产品的继承结构，如一个抽象类是单反相机，其子类有索尼单反相机、尼康单反相机、佳能单反相机，则抽象单反相机与具体品牌的单反相机之间构成了一个产品等级结构，抽象单反相机是父类，而具体品牌的单反相机是其子类。
产品族：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如佳能生产的单反相机、微单相机，佳能单反相机位于单反相机产品等级结构中，佳能微单相机位于微单相机等级结构中，佳能单反相机，佳能微单相机构成了一个产品族。

角色

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

优缺点

优点

客户端使用抽象工厂来创建需要的对象，而客户端根本就不知道具体的实现是谁，客户端只是面向产品的接口编程而已。也就是说，客户端从具体的产品实现中解耦。
增加新的产品族很方便，无须修改已有系统，符合“开闭原则”。

缺点

增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这显然会带来较大的不便，违背了“开闭原则”。

使用场景

一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。
这个系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。
系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。

示例

/**
* 抽象产品(AbstractProduct)
*/
public interface SLRCamera {
    void photographSLR();
}
/**
* 具体产品(ConcreteProduct)
*/
public class CanonSLRCamera implements SLRCamera {
    @Override
    public void photographSLR() {
        System.out.println("使用佳能单反拍照");
    }
}
/**
* 具体产品(ConcreteProduct)
*/
public class SONYSLRCamera implements SLRCamera {

    @Override
    public void photographSLR() {
        System.out.println("使用索尼单反拍照");
    }
}
/**
* 抽象产品(AbstractProduct)
*/
public interface MirrorlessCamera {
    void photographMirrorless();
}
/**
* 具体产品(ConcreteProduct)
*/
public class CanonMirrorlessCamera implements MirrorlessCamera {
    @Override
    public void photographMirrorless() {
        System.out.println("使用佳能微单拍照");
    }
}
/**
* 具体产品(ConcreteProduct)
*/
public class SONYMirrorlessCamera implements MirrorlessCamera {
    @Override
    public void photographMirrorless() {
        System.out.println("使用索尼微单拍照");
    }
}
/**
* 抽象工厂(AbstractFactory)
*/
public interface CameraFactory {
    SLRCamera factorySLR();

    MirrorlessCamera factoryMirror();
}
/**
* 具体工厂(ConcreteFactory)
*/
public class CanonCameraFactory implements CameraFactory {
    @Override
    public SLRCamera factorySLR() {
        return new CanonSLRCamera();
    }

    @Override
    public MirrorlessCamera factoryMirror() {
        return new CanonMirrorlessCamera();
    }
}
/**
* 具体工厂(ConcreteFactory)
*/
public class SONYCameraFactory implements CameraFactory{
    @Override
    public SLRCamera factorySLR() {
        return new SONYSLRCamera();
    }

    @Override
    public MirrorlessCamera factoryMirror() {
        return new SONYMirrorlessCamera();
    }
}
/**
* 测试类
*/
public class CameraTest {
    public static void main(String[] args) {
        CameraFactory cameraFactory = new SONYCameraFactory();
        cameraFactory.factorySLR().photographSLR();
        cameraFactory.factoryMirror().photographMirrorless();
    }
}