设计模式之抽象工厂模式---abstract factory

模式的介绍

模式的定义

Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

为创建一组相关的或相互依赖的对象提供一个接口，而无须指定他们的具体类。

类型

创造类

模式的使用场景

抽象工厂模式的使用场景定义非常简单：一个对象族(或一组没有任何关系的对象)都有相同的约束，则可以使用抽象工厂模式。

UML类图

角色介绍

(1)AbstractProduct类：抽象产品类的定义
(2)ConcretePorduct类：具体产品的实现
(3)AbstractFactory类：抽象工厂的定义
(4)ConcreteFactory类：具体工厂的实现

模式的简单实现

定义一个猫的抽象类：

public abstract class ACat {
    public abstract void color();
}

再实现一个黑猫类和白猫类：

public class WhiteCat extends ACat{

    @Override
    public void color() {
        // TODO Auto-generated method stub
        System.out.println("i am is a white cat");
    }
}

public class BlackCat extends ACat {

    @Override
    public void color() {
        // TODO Auto-generated method stub
        System.out.println("i am is a black cat");
    }
}

同样，定义一个狗的抽象类：

public abstract class ADog {
    public abstract void color();
}

实现二个颜色的具体狗类(黑狗，白狗)：

public class WhiteDog extends ADog {

    @Override
    public void color() {
        // TODO Auto-generated method stub
        System.out.println("i am is a white dog");
    }
}

public class BlackDog extends ADog {

    @Override
    public void color() {
        // TODO Auto-generated method stub
        System.out.println("i am is a black dog");
    }
}

定义一个抽象工厂类，定义二个接口，一个创建cat，一个创建dog:

public abstract class AFactory {
    /**create cat**/
    public abstract ACat createCat();
    /**create dot**/
    public abstract ADog createDog();
}

实现一个white的工厂，负责创建white的dog和cat：

public class WhiteColorFactory extends AFactory{

    @Override
    public ACat createCat() {
        // TODO Auto-generated method stub
        return new WhiteCat();
    }

    @Override
    public ADog createDog() {
        // TODO Auto-generated method stub
        return new WhiteDog();
    }
}

同样，实现一个black的工厂，负责创建black的dog和cat：

public class BlackColorFactory extends AFactory{

    @Override
    public ACat createCat() {
        // TODO Auto-generated method stub
        return new BlackCat();
    }

    @Override
    public ADog createDog() {
        // TODO Auto-generated method stub
        return new BlackDog();
    }
}

Client调用：

public class AbstractFactory {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        AFactory whiteColorFactory = new WhiteColorFactory();
        ACat whiteCat = WhiteColorFactory.createCat();
        whiteCat.color();
        ADog whiteDog = whiteColorFactory.createDog();
        whiteDog.color();

        AFactory blackColorFactory = new BlackColorFactory();
        ACat blackCat = BlackColorFactory.createCat();
        blackCat.color();
        ADog blackDog = blackColorFactory.createDog();
        blackDog.color();
    }
}

输出结果：

i am is a white cat
i am is a white dog
i am is a black cat
i am is a black dog

到此，我们会发现，我们的源码目录下已经有十个类了，实现一个这么简单的功能，我们竟然要用十个类，要是更复杂的产品关系，那会是把人淹死在类的汪洋大海里的节奏啊。那么结论来了，抽象工厂模式会产生许多中间类，导致复杂度增加，这也是此模式的一大缺点。

再来分析此模式，假如，我们要再添加一种颜色（如灰–gray）的cat和dog(也就是要在一个产品中新增一个等级)，我们可以如下修改：
我们再分别新建一个GrayCat和GrayDog类，再新增一个GrayColorFactory类分别创建gray cat和gray dog。需求通过简单的扩展就可以实现。修改后的类图如下：

假如，现在我们在添加一个创建猪(pig)的对象(也就是说要新增一个产品族)，那么，我们会发现，这个修改首先要在AFactory（工厂抽象类）中创建一个createPig抽象方法，然后再对应的把所有的具体的工厂类(BlackColorFactory ,WhiteColorFactory )都要对应的修改。非常明显，这严重违反了开闭原则。我们说抽象类和接口是一个契约，改变契约会导致所有与契约有关系的代码都要修改，那么这段代码叫“有毒代码”。这也是抽象工厂模式的另一个缺点。

也就是说 抽象工厂模式横向(新增产品等级)扩展容易，纵向(新增产品族)扩展困难。

模式的优缺点

优点

封装性
高层模块只关心工厂类的接口和抽象，只要知道工厂类的接口，我们就可以创建也一个需要的对象，省时省力。而工厂类则负责对象的创建细节。

缺点

抽象模式最大的缺点是口中间类比较多，增加了系统的复杂度，使用起来比较复杂。想想，光最简单的抽象工厂模式，与产品相关的类就达到了6个，与工厂相关的类也有3个，这里就有9个类，如果稍微复杂一点的产品，可以想象的到类的数目会更多，这也是我们平时比较少的用到此模式的根本原因。

抽象工厂模式的另一个缺点是产品族扩展困难。

Android源码中的模式实现

基于抽象工厂模式的缺点，我们应用此模式不多，我现在还没有在android源码中见到此模式，后补：

参考资料

(1)设计模式(二)—– 抽象工厂(AbstractFactory)—-(JAVA版)
http://blog.csdn.net/hfreeman2011/article/details/8350196
(2).设计模式之禅—第9章 抽象工厂模式