抽象工厂模式：

提供一个接口，用来创建相关或依赖对象的家族，而不需要明确指定具体类。

抽象工厂模式是工厂方法模式的升级版本。如果我们要实现的系统有N个产品族，每个产品族有M种产品，那么就可以使用抽象工厂模式。抽象工厂模式的结构可以分为：

• 抽象产品类/接口：定义每个产品族的共性特点，有多少个产品族就要定义多少个抽象产品类/接口。
• 产品实现类：每个具体产品肯定属于某个产品族，它要继承/实现相应的抽象产品类/接口。
• 抽象工厂类/接口：声明每个产品族的创建方法，有N个产品族，在抽象工厂类中就应该有N个创建方法。
• 实现工厂类：继承/实现相应的抽象工厂类/接口，实现不同产品族的生产任务。每个产品族有M种产品，就应该有M个实现工厂类。

示例代码如下：

假设我们有两个产品族，那么抽象产品类如下：

//抽象产品类Apublic abstract class AbstractProductA { ... }//抽象产品类Bpublic abstract class AbstractProductA { ... }

假设每个抽象产品族生产2中产品，那么产品实现类如下：

//产品族A生产的1级品public class ProductA1 extends AbstractProductA {     public void show() {  System.out.println("产品族A生产的1级品"); }}//产品族A生产的2级品public class ProductA1 extends AbstractProductA {     public void show() {  System.out.println("产品族A生产的2级品"); }}//产品族B生产的1级品public class ProductA1 extends AbstractProductA {     public void show() {  System.out.println("产品族B生产的1级品"); }}//产品族B生产的2级品public class ProductA1 extends AbstractProductA {     public void show() {  System.out.println("产品族B生产的2级品"); }}

有两个产品族，在抽象工厂类中就有两个创建方法：

抽象工厂类public abstract class AbstractCreator {     //创建A产品家族     public abstract AbstractProductA createProductA();      //创建B产品家族     public abstract AbstractProductB createProductB();}

在此例中应该有两个实现工厂类，分别生产1级品和2级品：

//产品等级1的实现类public class Creator1 extends AbstractCreator {         //生产A产品族的1级品     public Abstract ProductA createProductA() {  return new ProductA1(); }     //生产B产品族的1级品     public Abstract ProductB createProductB() {  return new ProductB1(); }}//产品等级2的实现类public class Creator2 extends AbstractCreator {         //生产A产品族的2级品     public AbstractProductA createProductA() {   return new ProductA2(); }     //生产B产品族的2级品     public AbstractProductB createProductB() {   return new ProductB2(); }}

上面就已经实现了抽象工厂设计模式，使用方法如下：

public class MyTest {     public static void main(String[] args) {         //定义出两个工厂         Abstract Creator creator1 = new Creator1();         Abstract Creator creator2 = new Creator2();         //产生A1对象         AbstractProductA a1 =  creator1.createProductA();         //产生A2对象         AbstractProductA a2 = creator2.createProductA();         //产生B1对象         AbstractProductB b1 = creator1.createProductB();         //产生B2对象         AbstractProductB b2 = creator2.createProductB();         ...     }}

• 优点：封装性----高层模块不需要知道每个产品的实现类，它只关心接口/抽象类。各种对象的创建由工厂类负责。工厂类就是一个对象工厂，我们需要什么对象只需让它生产一个即可。
• 缺点：产品族的扩展非常麻烦。