设计模式(二)----- 抽象工厂(AbstractFactory)----(JAVA版)

 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类

适用性：

1.一个系统要独立于它的产品的创建，组合和表示时

2.一个系统要由多个产品系列中的一个来配置时

3.当你要强调一系列相关的产品对象的设计以便进行联合使用时

4.当你提供一个产品类库，而只想显示它们接口而不是实现时

它有以下的优点
1：封装性，每个产品的实现类不是高层模块要关心的，它所要关心 的是接口和抽象类，他不关心对象是如何创建出来，只有工厂类去关心，只要知道工厂类是谁，我们就能得到一个需要的对象。

2：产品家族的约束为非公开状态。而抽象工厂模式针对的是多个产品等级结构。当每个抽象产品都有多于一个的具体子类的时候，工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色，分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

参与者：

1.AbstractFactory

   声明一个创建抽象产品对象的操作接口

2.ConcreteFactory

  实现创建具体产品对象的操作

3.AbstractProduct

  为一类产品对象声明一个接口

4.ConcreteProduct

  定义一个将被相应的具体工厂创建的产品对象

  实现AbstractProduct接口

类图：

一个简单的例子：

AbstractFactory

[java] view plain copy

1. public interface IAnimalFactory{  
2.     ICat createCat();  
3.     IDog createDog();  
4. }  

ConcreteFactory

[java] view plain copy

1. public class BlackAnimalFactory implements IAnimalFactory{  
2.   public ICat createCat(){  
3.     return new BlackCat();  
4.   }  
5.   public IDog createDog(){  
6.     return new BlackDog();  
7.   }  
8. }  

[java] view plain copy

1. public class WhiteAnimalFactory implements IAnimalFactory{  
2.   public ICat createCat(){  
3.     return new WhiteCat();  
4.   }  
5.   public IDog createDog(){  
6.     return new WhiteDog();  
7.   }  
8. }  

AbstractProduct

[java] view plain copy

1. public interface ICat{  
2.   void eat();  
3. }  

[java] view plain copy

1. public interface IDog{  
2.   void eat();  
3. }  

ConcreteProduct

[java] view plain copy

1. public class BlackCat implements ICat{  
2.   public void eat(){  
3.       System.out.println("the black cat is eating");  
4.   }  
5. }  

[java] view plain copy

1. public class WhiteCat implements ICat{  
2.   public void eat(){  
3.       System.out.println("the white cat is eating");  
4.   }  
5. }  

[java] view plain copy

1. public class BlackDog implements IDog{  
2.   public void eat(){  
3.       System.out.println("the black dog is eating");  
4.   }  
5. }  

[java] view plain copy

1. public class WhiteDog implements IDog{  
2.   public void eat(){  
3.       System.out.println("the white dog is eating");  
4.   }  
5. }  

Test

[java] view plain copy

1. public class Test{  
2.   public static void main(String[] args){  
3.      IAnimalFactory blackAnimalFactory = new BlackAnimalFactory();  
4.      ICat blackCat = blackAniamlFactory.createCat();   
5.      blackCat.eat();  
6.   
7.      IDog blackDog = blackAnimalFactory.createDog();  
8.      blackDog.eat();  
9.   
10.      IAnimalFactory whiteAnimalFactory = new WhiteAnimalFactory();  
11.      ICat whiteCat = whiteAnimalFactory.createCat();  
12.      whiteCat.eat();  
13.   
14.      IDog whiteDog = whiteAnimalFactory.createDog();  
15.      whiteDog.eat();  
16. }  

result:

the black cat is eating

the black dog is eating

the white cat is eating
the white dog is eating

    抽象工厂方法从纵向上看，几乎没有可扩展性，假如我们想增加一个老虎，也就是说产品家族由原来的2个变为3个，程序将会有很大的变动，抽象工厂中就需要增加一个方法。这严重违背了开闭原则。并且抽象类是不喜欢被修改的。

    但是从横向上来看，却对扩展性有了很好的支持，如果我们增加一个产品如greenCat,greenDog,我们只需要在写一个GreenAnimalFactory类就可以了，这里又符合了开闭原则，有多少个产品等级就应该有多少个实现工厂类。每增加一个产品等级就相应的增加一个实现工厂类，这里的扩展性又很自然的体现出来了。

参考资料：

1.http://gengu.iteye.com/blog/1125260

2.http://www.cnblogs.com/devinzhang/archive/2011/12/19/2293160.html