工厂模式：用来实例化有共同接口的类，应用工厂模式可以动态决定实例化哪一个类

工厂模式的分类：

1、简单工厂模式（Simple Factory）

2、工厂方法模式（Factory Method）

3、抽象工厂模式（Abstruct Factory）

（本文只介绍抽象工厂模式，想了解简单工厂模式与工厂方法模式请到http://www.cnblogs.com/Not-Famous/p/3648535.html）

另外，本文转自http://blog.csdn.net/liruikqn/article/details/12888511，本人根据个人理解，稍有删改。

 

　　抽象工厂模式（Abstract Factory）是工厂方法模式的进一步抽象，其英文原话"Provide an interface for creating families of related or dependent objects without specifying their concrete classes",翻译，“为创建一组相关或相互依赖的对象提供一个接口，无需指定它们的具体类”。抽象工厂模式通常是用于创一族产品，并且这族产品分不同的等级；不同的具体工厂类生产不同等级的一族产品。抽象工厂模式也有四种角色：抽象工厂、具体工厂、抽象产品和具体产品。抽象工厂模式的类图如下：

 

　　可以看到产品族包括ProductA和ProductB两种产品，每个具体工厂都能生产这两种产品，只是ConcreteFactory1生产的等级为1的族产品；ConcreteFactory2生产的是等级为2的族产品。下面以上图为模型，写一个demo，测试抽象工厂模式。

1.定义抽象工厂接口

1 //抽象工厂，定义了生产族产品的方法；
2 public interface AbstractFactory {
3     public ProductA factoryA();
4     public ProductB factoryB();
5 }

2.定义产品A接口

1 //抽象产品A定义了产品的公共方法，产品A和B属于一个产品族
2 public interface ProductA {
3     public void method1();
4     public void method2();
5 }

3.定义产品B接口

1 //抽象产品A定义了产品的公共方法，产品A和B属于一个产品族
2 public interface ProductA {
3     public void method1();
4     public void method2();
5 }

4.定义生产等级为1的族产品的具体工厂的类

 1 //ConcreateFactory1是用来生产等级为1的产品A，B；
 2 public class ConcreateFactory1 implements AbstractFactory {
 3 
 4     //生产等级为1的产品A
 5     @Override
 6     public ProductA factoryA() {
 7         // TODO Auto-generated method stub
 8         return new ConcreateProductA1();
 9     }
10 
11     
12     //生产等级为1的产品B
13     @Override
14     public ProductB factoryB() {
15         // TODO Auto-generated method stub
16         return new ConcreateProductB1();
17     }
18 
19 }

5.定义生产等级为2的族产品的具体工厂的类

 1 //ConcreateFactory2是用来生产等级为1的产品A，B；
 2 public class ConcreateFactory2 implements AbstractFactory {
 3 
 4     //生产等级为2的产品A
 5     @Override
 6     public ProductA factoryA() {
 7         // TODO Auto-generated method stub
 8         return new ConcreateProductA2();
 9     }
10 
11     
12     //生产等级为2的产品B
13     @Override
14     public ProductB factoryB() {
15         // TODO Auto-generated method stub
16         return new ConcreateProductB2();
17     }
18 
19 }

6.定义等级为1的产品A（具体产品）的类

//等级为1的具体产品A
public class ConcreateProductA1 implements ProductA {

    @Override
    public void method1() {
        // TODO Auto-generated method stub
        System.out.println("等级为1的产品A的method1()");
    }

    @Override
    public void method2() {
        // TODO Auto-generated method stub
        System.out.println("等级为1的产品A的method2()");
    }
}

7.定义等级为2的产品A（具体产品）的类

 1 //等级为2的具体产品A
 2 public class ConcreateProductA2 implements ProductA {
 3 
 4     @Override
 5     public void method1() {
 6         // TODO Auto-generated method stub
 7         System.out.println("等级为2的产品A的method1()");
 8     }
 9 
10     @Override
11     public void method2() {
12         // TODO Auto-generated method stub
13         System.out.println("等级为2的产品A的method2()");
14     }
15 }

8.定义等级为1的产品B（具体产品）的类

 1 //等级为1的产品B
 2 public class ConcreateProductB1 implements ProductB{
 3 
 4     @Override
 5     public void method1() {
 6         // TODO Auto-generated method stub
 7         System.out.println("等级为1的产品B的method1()");
 8     }
 9 
10     @Override
11     public void method2() {
12         // TODO Auto-generated method stub
13         System.out.println("等级为1的产品B的method2()");
14     }
15 }

9.定义等级为2的产品B（具体产品）的类

 1 //等级为2的产品B
 2 public class ConcreateProductB2 implements ProductB {
 3 
 4     @Override
 5     public void method1() {
 6         // TODO Auto-generated method stub
 7         System.out.println("等级为2的产品B的method1()");
 8     }
 9 
10     @Override
11     public void method2() {
12         // TODO Auto-generated method stub
13         System.out.println("等级为2的产品B的method2()");
14     }
15 }

　　由此可知，抽象工厂模式相对于工厂方法模式来说，每个具体工厂可以生产一族产品（即多种产品）；而工厂方法模式是具体工厂生产相应的具体产品，只能生产一种产品。当产品族中只有一种产品时抽象工厂模式退化成工厂方法模式。

　　以上便是抽象工厂模式的内容，层次会比较复杂，建议读者结合代码和类图来理解！