关于抽象工厂的学习理解

本文是在学习中的总结，欢迎转载但请注明出处：http://blog.csdn.net/pistolove/article/details/46440915

抽象工厂模式是对象的创建模式，它是工厂方法模式的进一步推广。


抽象工厂模式与工厂方法模式的最大区别就在于工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则需要面对多个产品等级结构。

假设一个子系统需要一些产品对象，而这些产品又属于一个以上的产品等级结构。那么为了将消费这些产品对象的责任和创建这些产品对象的责任分割开来，可以引进抽象工厂模式。这样的话，消费产品的一方不需要直接参与产品的创建工作，而只需要向一个公用的工厂接口请求所需要的产品。

优点:

（1）分离接口和实现
　　客户端使用抽象工厂来创建需要的对象，而客户端根本就不知道具体的实现是谁，客户端只是面向产品的接口编程而已。也就是说，客户端从具体的产品实现中解耦。

（2）使切换产品族变得容易
　　因为一个具体的工厂实现代表的是一个产品族，比如上面例子的从A产品到B产品只需要切换一下具体工厂。

缺点:
（1）不太容易扩展新的产品
　　如果需要给整个产品族添加一个新的产品，那么就需要修改抽象工厂，这样就会导致修改所有的工厂实现类。

通过下面代码来熟悉抽象工厂模式：

不同的抽象工厂：

（不同的工厂用来生产不同的产品）

[java] view plain copy

1. package com.design.abstractFactory;  
2.   
3. //每一种牌子的产品负责生产工厂，即不同的厂商负责自己牌子的生产  
4. public abstract class Factory1 {  
5.     abstract public IproductA getproductA1();  
6.     abstract public IproductB getProductB1();  
7. }  

[java] view plain copy

1. package com.design.abstractFactory;  
2.   
3. public abstract class Factory2 {  
4.     abstract public IproductA getproductA2();  
5.     abstract public IproductB getproductB2();  
6. }  

不同的具体工厂：

（实现抽象工厂的方法，返回具体生产的产品）

[java] view plain copy

1. package com.design.abstractFactory;  
2.   
3. //具体的工厂生产产品  
4. public class ConcreateFactory1 extends Factory1 {  
5.   
6.     @Override  
7.     public IproductA getproductA1() {  
8.         return new ProductA1();  
9.     }  
10.   
11.     @Override  
12.     public IproductB getProductB1() {  
13.         return new ProductB1();  
14.     }  
15.   
16. }  

[java] view plain copy

1. package com.design.abstractFactory;  
2.   
3. public class ConcreateFactory2  extends Factory2{  
4.   
5.     @Override  
6.     public IproductA getproductA2() {  
7.         return new ProductA2();  
8.     }  
9.   
10.     @Override  
11.     public IproductB getproductB2() {  
12.         return new ProductB2();  
13.     }  
14. }  

定义不同的产品接口：

（产品接口用来统一产品的生产方法）

[java] view plain copy

1. package com.design.abstractFactory;  
2. //定义不同的产品之间的一定具备的标准，用interface实现   
3. public interface IproductA {  
4.     public void method();  
5. }  

[java] view plain copy

1. package com.design.abstractFactory;  
2.   
3. public interface IproductB {  
4.     public void method();  
5. }  

不同的具体产品：

（具体的实现，在使用时声明抽象工厂，调用具体实现）

[java] view plain copy

1. package com.design.abstractFactory;  
2.   
3. //实现了产品标准实现的一系列具体产品  
4. public class ProductA1 implements IproductA {  
5.   
6.     @Override  
7.     public void method() {  
8.         System.err.println("A1产品生产A1");  
9.     }  
10.   
11. }  

[java] view plain copy

1. package com.design.abstractFactory;  
2.   
3. public class ProductA2 implements IproductA {  
4.   
5.     @Override  
6.     public void method() {  
7.         System.err.println("A2生产产品A2");  
8.     }  
9.   
10. }  

[java] view plain copy

1. package com.design.abstractFactory;  
2.   
3. public class ProductB1 implements IproductB {  
4.     @Override  
5.     public void method() {  
6.         System.err.println("B1生产产品B1");  
7.     }  
8. }  

[java] view plain copy

1. package com.design.abstractFactory;  
2.   
3. public class ProductB2 implements IproductB {  
4.     @Override  
5.     public void method() {  
6.         System.err.println("B2生产产品B2");  
7.     }  
8. }  

客户端实现：

[java] view plain copy

1. package com.design.abstractFactory;  
2.   
3. public class Client {  
4.     public static void main(String[] args) {  
5.   
6.         Factory1 factory = new ConcreateFactory1();  
7.   
8.         IproductA a1 = factory.getproductA1();  
9.   
10.         IproductB b1 = factory.getProductB1();  
11.   
12.         a1.method();  
13.   
14.         b1.method();  
15.   
16.     }  
17. }  

抽象工厂的使用：

1.声明抽象工厂

2.具体实现抽象工厂

3.定义产品统一的生产方式

4.具体产品实现生产方式生产不同的产品

5.声明抽象工厂，调用不同的具体实现工厂，生产不同的产品。

测试结果：

A1产品生产A1
B1生产产品B1