《设计模式之抽象工厂模式》

1.抽象工厂模式定义

抽象工厂模式的英文原话：
Provide an interface for creating families of related or dependent objects whitout specifying their concrete classed.
意思是：为创建一组相关或者相互依赖的的对象提供一个借口，而且无需指定它们的具体类。抽象工厂模式是工厂模式的升级版本。在多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方法。
抽象工厂模式类图：

抽象工厂模式的角色分配与工厂模式一致。

2.抽象工厂模式的应用

抽象工厂模式是工厂模式的进一步抽象，针对的是一族产品。如果产品族中只有一种产品，则抽象工厂模式退化为工厂模式。除了工厂模式的优点，抽象工厂模式还有以下有优点：
1）产品族内的约束为非公开状态，在不同的工厂中，各种产品可能具有不同的相互依赖关系，这些依赖关系由工厂封装在内部，对于工厂的使用者是不可见的。
2）生产线的扩展非常容易，如果要针对同一产品的族建立新的生产线，只需要实现产品族中的所有产品接口，并建立显得工厂类即可。
抽象工厂的缺点：
抽象工厂模式最大的缺点就是产品族本身扩展非常困难，如果需要在产品族中增加一个新的产品类型，则需要修改多个接口，并且会影响已有的工厂类。

3.抽象工厂模式的实例

参照前面抽象工厂模式类图。
AbstractFactory.java

public interface AbstractFactory {

    public ProductA factoryA();

    public ProductB factoryB();

}

ConcreteFactory1.java

public class ConcreteFactory1 implements AbstractFactory {

    public ProductA factoryA(){
        return new ProductA1();
    }

    public ProductB factoryB(){
        return new ProductB1();
    }

}

ConcreteFactory2.java

public class ConcreteFactory2 implements AbstractFactory {

    public ProductA factoryA(){
        return new ProductA2();
    }

    public ProductB factoryB(){
        return new ProductB2();
    }

}

ProductA.java

public interface ProductA {

    public void method1();

    public void method2();

}

ProductB.java

public interface ProductB {

    public void method1();

    public void method2();

}

ProductA1.java

public class ProductA1 implements ProductA {

    public void method1(){
        System.out.println("产品A1的方法1实现了。");
    }

    public void method2(){
        System.out.println("产品A1的方法2实现了。");
    }

}

ProductA2.java

public class ProductA2 implements ProductA {

    public void method1(){
        System.out.println("产品A2的方法1实现了。");
    }

    public void method2(){
        System.out.println("产品A2的方法2实现了。");
    }

}

ProductB1.java

public class ProductB1 implements ProductB {

    public void method1(){
        System.out.println("产品B1的方法1实现了。");
    }

    public void method2(){
        System.out.println("产品B2的方法2实现了。");
    }

}

Productb2.java

public class ProductB2 implements ProductB {

    public void method1(){
        System.out.println("产品B2的方法1实现了。");
    }

    public void method2(){
        System.out.println("产品B2的方法2实现了。");
    }

}

TestAbstractFactory.java

public class TestAbstractFactory{

     public static void main(String[] argv){

         AbstractFactory factory1 = new ConcreteFactory1();
         AbstractFactory factory2 = new ConcreteFactory2();

         ProductA productA1 = factory1.factoryA();
         ProductB productB1 = factory1.factoryB();
         System.out.println("工厂1开始成产A1、B1产品");
         productA1.method1();
         productA1.method2();
         productB1.method1();
         productB1.method2();

         ProductA productA2 = factory2.factoryA();
         ProductB productB2 = factory2.factoryB();
         System.out.println("工厂2开始成产A2、B2产品");
         productA2.method1();
         productA2.method2();
         productB2.method1();
         productB2.method2();

     }
 }

4.测试结果

工厂1开始成产A1、B1产品                                                                                                                                                            
产品A1的方法1实现了。                                                                                                                                                              
产品A1的方法2实现了。                                                                                                                                                              
产品B1的方法1实现了。                                                                                                                                                              
产品B2的方法2实现了。                                                                                                                                                              
工厂2开始成产A2、B2产品                                                                                                                                                            
产品A2的方法1实现了。                                                                                                                                                              
产品A2的方法2实现了。                                                                                                                                                              
产品B2的方法1实现了。                                                                                                                                                              
产品B2的方法2实现了。