Java 设计模式之抽象工厂模式的详解（创建模式）

抽象工厂模式(Abstract Factory)是工厂方法里面最为抽象和最具一般性的形态，是指当有多个抽象角色时，使用的一种工厂模式。

抽象工厂模式概念：可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。

抽象工厂模式和工厂方法模式的区别：

1.工厂方法模式：

一个抽象产品类，可以派生出多个具体产品类

一个抽象工厂类，可以派生出多个具体工厂类

每个具体工厂类只能创建一个具体产品类

2.抽象工厂模式：

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类

一个抽象工厂类，可以派生出多个具体工厂类

每个具体工厂类可以创建多个具体产品类，也就是创建的是一个产品线下的多个产品

3.对于java来说，你能见到的大部分抽象工厂模式都是这样的：

它的里面是一堆工厂方法，每个工厂方法返回某种类型的对象。

抽象工厂模式的一般示意类图如下：

下面我们先看抽象工厂的角色都有哪些：
抽象工厂(Creator)角色：是抽象工厂模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
具体工厂(Concrete Creator)角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。
抽象产品(Product)角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。
具体产品(Concrete Product)角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

如果你很留心，你就发现抽象工厂的角色和工厂方法的角色一样，其实抽象工厂就是在工厂方法的基础上进一步推广。

下面我们来举实例说明：

先看下关系图：

抽象工厂类：

public interface AbstractFactory {  
    //创建产品A  
    public ProductA factoryA();  
    //创建产品B  
    public ProductB factoryB();  
    //更多创建产品.....  
}  

抽象产品类：

public interface ProductA{  
    //产品A公共方法  
    public void method1();    
    public void method2();    
   //更多产品逻辑.....  
}  

public interface ProductB{  
    //产品B公共方法  
    public void method1();    
    public void method2();    
   //更多产品逻辑.....  
}

具体产品类：

public class ProductA1 implements ProductA {

	@Override
	public void method1() {
		// TODO Auto-generated method stub
       System.out.println("A1--method1");
	}

	@Override
	public void method2() {
		// TODO Auto-generated method stub

		System.out.println("A1--method2");
	}

}

public class ProductA2 implements ProductA {

	@Override
	public void method1() {
		// TODO Auto-generated method stub
System.out.println("A2--method1");
	}

	@Override
	public void method2() {
		// TODO Auto-generated method stub
System.out.println("A2--method2");
	}

}

public class ProductB1 implements ProductB {

	@Override
	public void method1() {
		// TODO Auto-generated method stub
System.out.println("B1--method1");
	}

	@Override
	public void method2() {
		// TODO Auto-generated method stub
System.out.println("B1--method2");
	}

}

public class ProductB2 implements ProductB {

	@Override
	public void method1() {
		// TODO Auto-generated method stub
System.out.println("B2--method1");
	}

	@Override
	public void method2() {
		// TODO Auto-generated method stub
System.out.println("B2--method2");
	}

}

具体工厂类：

public class ConcreateFactory1 implements AbstractFactory {  
    //建造者  
    @Override  
    public ProductA factoryA() {  
        //生产等级为1的产品A,即A1  
        return new ProductA1();  
    }  
  
    @Override  
    public ProductB factoryB() {  
        //生产等级为1的产品B,即B1  
        return new ProductB1();  
    }  
    //更多代码逻辑......  
}  

public class ConcreateFactory2 implements AbstractFactory {  
    @Override  
    public ProductA factoryA() {  
        //生产等级为2的产品A,即A2  
        return new ProductA2();  
    }  
    @Override  
    public ProductB factoryB() {  
        //生产等级为2的产品B,即B2  
        return new ProductB2();  
    }  
    //更多代码逻辑......  
}

测试类：

public class Test {
	//客户端--调用者  
    public static void main(String[] args) {  
        //定义两个工厂，等级为1和等级为2  
       ConcreateFactory1 factory1=new ConcreateFactory1();  
       ConcreateFactory2 factory2=new ConcreateFactory2();  
       //定义A产品的不同系列产品  
       ProductA a1=factory1.factoryA();  
       ProductA a2=factory2.factoryA();  
       //定义A产品的不同系列产品  
       ProductB b1=factory1.factoryB();  
       ProductB b2=factory2.factoryB();  
       //业务逻辑  
       a1.method1();  
       b1.method1();  
       a2.method1();  
       b2.method1();  
       //更多业务逻辑....  
   }  
}

结果为：

A1--method1
B1--method1
A2--method1
B2--method1

这种模式的优点：

具体产品从客户代码中被分离出来

容易改变产品的系列

将一个系列的产品族统一到一起创建

缺点：

对于新增加的产品，无能为力，支持增加产品族, 在产品族中扩展新的产品是很困难的，它需要修改抽象工厂的接口