设计模式之抽象工厂

这篇说说工厂的最后一种，还是先上 

抽象工厂模式定义(来自百度百科)：
        抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。
抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据里氏替换原则，
任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的，仅仅是类型与这些抽象产品角色相同的一些实例，而不是这些抽象产品的实例。
换言之，也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。

UML 类图

具体代码：

public class Client {
    public static void main(String[] args) {
//        Creator benzCreator = new BenzCreator();
//        benzCreator.createCar().run();
//
//        Creator bmwCreator = new BmwCreator();
//        bmwCreator.createCar().run();

        AbstractFactory factory1 = new Factory1();
        factory1.createProductA().getProductAName();
        factory1.createProductB().getProductBName();

        AbstractFactory factory2 = new Factory2();
        factory2.createProductA().getProductAName();
        factory2.createProductB().getProductBName();
    }
}

public interface AbstractFactory {
    AbstractProductA createProductA();

    AbstractProductB createProductB();
}

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

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

public class Factory2 implements AbstractFactory {

    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

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


public interface AbstractProductA {
       String getProductAName();
}

public class ProductA1 implements AbstractProductA {
    ProductA1(){
        System.out.println("产品A1");
    }

    @Override
    public String getProductAName() {
        return "产品A1名称";
    }
}

public class ProductA2 implements AbstractProductA {
    ProductA2(){
        System.out.println("产品A2");
    }

    @Override
    public String getProductAName() {
        return "产品A2名称";
    }
}



public interface AbstractProductB {
    String getProductBName();
}

public class ProductB1 implements AbstractProductB {
    ProductB1(){
        System.out.println("产品B1");
    }

    @Override
    public String getProductBName() {
        return "产品B1名称";
    }
}

public class ProductB2 implements AbstractProductB {
    ProductB2(){
        System.out.println("产品B2");
    }

    @Override
    public String getProductBName() {
        return "产品B2名称";
    }
}

产品族:

     是指位于不同产品等级结构中，功能相关联的产品组成的家族

具体例子：

     我举个可能不大恰当的例子
     例如我们电脑都是 32和64位的 对应的机器安装对应位数的软件
两张光盘 分别存储32位和64位的软件 那装机的时候 只需要拿一张光盘就搞定的整机软件安装 不用挨个软件去找。
这里 光盘就是具体的工厂 如果每张光盘都有QQ和360(就是要打架 怎样？)
这里32位的光盘 就是上面代码里的Factory1 这里64位的光盘 就是上面代码里的Factory2
32位的光盘里的QQ就是ProductA1，360就是ProductB1
64位的光盘里的QQ就是ProductA2，360就是ProductB2

对于我这小白用户，拿对光盘就行了，不需要既找对QQ的位数又找到360的位数，是不是很爽。

优缺点
优点：
      分离接口和实现，这样客户端不需要知道具体的实现。
      产品族的切换变得容易，就像如果出现128位的机器，无非多加一张光盘。

缺点：
     不容易扩展新产品（想象一下增加一个产品要加多少类和方法吧）。
    类的层级结构复杂（看看类图都是想吐的有木有）

本质：

       之前说过工厂方法的本质就是选择实现，就是选择具体的产品
那抽象工厂就是选择产品族，由单一产品变成产品族而已。

三种工厂模式说完了，他们之间的联系区别和演化过程就先挖个坑，之后再写。