抽象工厂模式（Abstract Factory Pattern）

一，抽象工厂

抽象工厂进一步对工厂进行了抽象，是围绕一个超级工厂创建其他工厂，创建出来的工厂再创建具体的产品。该超级工厂又称为其他工厂的工厂。
抽象工厂模式的组成：

1. 抽象工厂：抽象工厂模式的核心，是对简单工厂的进一步升级和抽象，抽象工厂创建具体工厂。
2. 具体工厂：每个具体工厂可以直接提供对应的具体产品类的实例对象
3. 抽象产品：这是对一系列产品的抽象，不提供具体的业务逻辑
4. 具体产品：是抽象产品的具体化，负责具体业务逻辑的实现

下面以电脑和手机为例子进行说明：

---

二，抽象工厂的实现

1，编写抽象产品接口

//抽象产品类
interface Computer
{
    void work();
}

//抽象产品类CellPhone
interface CellPhone
{
    void call();
}

2，编写具体产品类

//实现类Asus
class Asus implements Computer
{

    @Override
    public void work()
    {
        System.out.println("this is a computer of "+this.getClass().getName()+" which is running!");
    }
}
//实现类Lenovo
class Lenovo implements Computer
{

    @Override
    public void work()
    {
        System.out.println("this is a computer of "+this.getClass().getName()+" which is running!");
    }
}
//实现类Acer
class Acer implements Computer
{

    @Override
    public void work()
    {
        System.out.println("this is a computer of "+this.getClass().getName()+" which is running!");
    }
}

//实现类Iphone
class Iphone implements CellPhone
{

    @Override
    public void call() 
    {
        System.out.println("i am using this phone "+this.getClass().getName()+" for calling!");
    }
}
//实现类Nokia
class Nokia implements CellPhone
{

    @Override
    public void call() 
    {
        System.out.println("i am using this phone "+this.getClass().getName()+" for calling!");
    }
}
//实现类Vivo
class Vivo implements CellPhone
{

    @Override
    public void call() 
    {
        System.out.println("i am using this phone "+this.getClass().getName()+" for calling!");
    }
}

3，实现抽象工厂类

//创建抽象工厂
abstract  class AbstractFactory
{
    //生产电脑的方法，具体实现由具体的电脑工厂完成
    public abstract <T extends Computer> T createComputer(Class<T> computerName);
    //生产手机的方法，具体实现由具体的手机工厂完成
    public abstract <T extends CellPhone> T createCellPhone(Class<T> phoneName);
}

4，创建具体工厂，并实现抽象工厂中的抽象方法

//编写具体工厂类
class ComputerFactory extends AbstractFactory
{
    @SuppressWarnings("unchecked")
    public <T extends Computer> T createComputer(Class<T> computerName)
    {
        T computer = null;
        try {
            computer = (T)Class.forName(computerName.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("你要创建的实例："+computerName+"不存在");
            throw new RuntimeException(e);
        }
        return computer;
    }

    @Override
    public <T extends CellPhone> T createCellPhone(Class<T> phoneName) {
        // TODO Auto-generated method stub
        return null;
    }
}

//编写具体工厂类
class CellPhoneFactory extends AbstractFactory
{
    @SuppressWarnings("unchecked")
    public <T extends CellPhone> T createCellPhone(Class<T> phoneName)
    {
        T phone = null;
        try {
            phone = (T)Class.forName(phoneName.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("你要创建的实例："+phoneName+"不存在");
            throw new RuntimeException(e);
        }
        return phone;
    }

    @Override
    public <T extends Computer> T createComputer(Class<T> computerName) {
        // TODO Auto-generated method stub
        return null;
    }
}

5，编写测试方法

public static void testAbstractFactory()
    {
        //创建两个具体工厂对象
        AbstractFactory factory1 = new ComputerFactory();
        AbstractFactory factory2 = new CellPhoneFactory();

        //由具体工厂对象创建具体产品实例
        Asus asus = factory1.createComputer(Asus.class);
        Acer acer = factory1.createComputer(Acer.class);

        //调用产品方法
        asus.work();
        acer.work();

        //由具体工厂对象创建具体产品实例
        Iphone iphone = factory2.createCellPhone(Iphone.class);
        Nokia nokia = factory2.createCellPhone(Nokia.class);

        //调用产品方法
        iphone.call();
        nokia.call();
    }

6，方法调用

public static void main(String[] args)
    {
        testAbstractFactory();
    }

7，运行结果

this is a computer of designpattern.Asus which is running!
this is a computer of designpattern.Acer which is running!
i am using this phone designpattern.Iphone for calling!
i am using this phone designpattern.Nokia for calling!

8，抽象工厂的优缺点
优点：还是提供了扩展性，降低了程序间的耦合性
缺点：如果日后要增加其他产品的话，我们需要在抽象工厂中增加一个生产该产品的方法，并且要提供一个该产品的具体工厂继承抽象工厂，再在该工厂中提供生产该产品的方法。另外不知道有没有人注意到，在抽象工厂中，针对每种产品都提供了一个生产该产品的抽象方法，由其子类实现，但是如果每个具体工厂只负责生产对应的单一产品的话，它不仅需要实现生产自己产品的方法，还要实现生产其他产品的方法，尽管那些方法可以只提供空实现，即方法体为空。但是在具体工厂的类体中无疑增添了许多冗余无用的代码。

//创建抽象工厂
abstract  class AbstractFactory
{
    //生产电脑的方法，具体实现由具体的电脑工厂完成
    public abstract <T extends Computer> T createComputer(Class<T> computerName);
    //生产手机的方法，具体实现由具体的手机工厂完成
    public abstract <T extends CellPhone> T createCellPhone(Class<T> phoneName);
}

//编写具体工厂类
class CellPhoneFactory extends AbstractFactory
{
    @SuppressWarnings("unchecked")
    public <T extends CellPhone> T createCellPhone(Class<T> phoneName)
    {
        T phone = null;
        try {
            phone = (T)Class.forName(phoneName.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("你要创建的实例："+phoneName+"不存在");
            throw new RuntimeException(e);
        }
        return phone;
    }

    @Override
    public <T extends Computer> T createComputer(Class<T> computerName) {
        //尽管我不生产电脑，可以我也要实现这个方法，因为这个方法在父类中是抽象方法
        //设想要是有成千上万个产品，父类提供那么多对应的方法，即使我只生产一种产品，
        //却要实现所有抽象方法，实在是太痛苦，代码也不优雅
        return null;
    }
}

三，抽象工厂模式和工厂模式的区别

---

抽象工厂模式与工厂模式的区别：
工厂模式：定义一个用于创建对象的借口，让子类决定实例化哪一个类
抽象工厂模式：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类
我自己的理解是工厂模式一般针对单一的产品，如果产品不多用工厂模式即可，如果产品很多，那么我们需要对每种产品建立生产对应产品的工厂，这样我们就需要向上抽象一个工厂来对这些工厂进行管理，这样就形成了抽象工厂模式。

注：抽象工厂还是比较难理解的，自己感觉理解得也不是很到位，如果有错的地方望提醒包涵，欢迎打扰讨论。

---

参考链接：
http://www.runoob.com/design-pattern/abstract-factory-pattern.html
https://blog.csdn.net/seu_calvin/article/details/52268027
http://blog.csdn.net/ipqxiang/article/details/1955677