设计模式之三抽象工厂模式

     抽象工厂模式的定义：提供一个或者一系列相关或者相互依赖的接口，而无需指定它们的具体实现类

     与简单工厂和工厂模式不同的是抽象工厂模式用于处理当要创建一系列的产品对象，而且这一系列的对象是构建新的对象所需要的组成部分，也就是这系列需要创建的对象之间是有相互约束的。

     在抽象工厂模式中，会定义一个抽象工厂，在里面虚拟的创建客户端需要的这一系列对象，所谓虚拟的就是定义创建这些对象的抽象方法，并不去真正的实现，然后由具体的抽象工厂的子类来提供这一系列对象的创建，这样的话就可以为同一个抽象工厂提供很多不同的实现，也就是说抽象工厂在这里起到一个约束的作用，让所有子类有统一的外观来让客户端调用。

                                

     
                                                              

                                                           抽象工程模式的结构示意图

          AbstractFactory：抽象工厂，定义一系列创建产品的操作接口

         ConcreteFactroy：具体工厂，实现抽象工厂中的方法，具体实现一系列产品的创建

         AbstractProduct：定义一类产品对象的接口

         ConcreteProduct：具体的产品实现对象

         Client：客户端，主要使用抽象工厂来获取一系列所需要的产品对象，然后面向这些产品对象编程，以实现所需要的功能

          

            具体代码实现:

package 设计模式;

/**
 * 
 * <p>Title: Client</p>
 * <p>Description: 抽象工厂测试类</p>
 * @author	yangchen
 * @date	2016年5月21日上午11:23:06
 */

//抽象产品A
interface AbstractProductA{
	void doSomethingA();
}

//抽象产品B
interface AbstractProductB{
	void doSomethingB();
}

//产品A的具体实现类1
class ProductA1 implements AbstractProductA{

	@Override
	public void doSomethingA() {
		System.out.println("产品A1的具体实现");
	}
	
}

class ProductA2 implements AbstractProductA{

	@Override
	public void doSomethingA() {
		System.out.println("产品A2的具体实现");
	}
	
}

//产品B的具体实现类
class ProductB1 implements AbstractProductB{

	@Override
	public void doSomethingB() {
		System.out.println("产品B1的具体实现");
	}
	
}

//产品B的具体实现类
class ProductB2 implements AbstractProductB{

	@Override
	public void doSomethingB() {
		System.out.println("产品B2的具体实现");
	}
	
}

//抽象工厂
interface AbstractFactroy{
	AbstractProductA createProductA();
	AbstractProductB createProductB();
}

//具体的工厂实现对象1，实现创建产品对象的操作
class ContreteFactroy1 implements AbstractFactroy{

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

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

//具体的工厂实现对象2，实现创建产品对象的操作
class ContreteFactroy2 implements AbstractFactroy{

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

	@Override
	public AbstractProductB createProductB() {
		return new ProductB2();
	}
	
}
//客户端
<pre name="code" class="java">public class Client {
	public static void main(String[] args) {
		AbstractFactroy factory = new ContreteFactroy1();
		AbstractProductA pa = factory.createProductA();//通过抽象工程来获取产品对象
		AbstractProductB pb = factory.createProductB();
		
		pa.doSomethingA();
		pb.doSomethingB();
		
	}
}

 

总结：

    抽象工厂模式的优点：

          (1) 分离接口和实现：客户端通过面向接口编程，使用抽象工程来创建需要的对象，客户端不需要知道具体的实现类是什么，让客户端从具体的产品实现类中解耦

          (2) 切换产品簇变得容易：客户端可以选择不同的工厂实现，如代码所示只需要把ContreteFactroy1变成ContreteFactory2

   抽象工厂模式的缺点：

         (1) 不容易扩展新的产品：如果需要添加新的产品，就得修改抽象工厂以及抽象工厂实现类

         (2) 容易造成类层次复杂：考虑到这样一种情况，如果ProductA1还可以有不同的实现那么就得将抽象工厂再次分层，每层负责一种选择，这也就是容易造成复杂的类层次结构