单例模式写的太匆忙,今天写工厂模式,顺便简单的说下UML类图四种关系：依赖,关联,泛化(继承)和实现。

说说依赖与关联的区别

依赖： 

关联：

注意箭头，关联更像是依赖的一种扩展。 

工厂模式：

工厂模式，通常指的三个模式： 简单工厂，抽象工厂，工厂方法 三个模式（其实我不大喜欢他们这个命名，刚开始的时候并不能把他们当做模式的名称，尤其工厂方法）。简单工厂模式有时候不被叫做一种设计模式（你只需要知道，这并不重要），我们遵循主流原则，把简单工厂当做一种设计模式，并首先介绍。

看UML图：

这个图中，Factory类作为工厂，专门生产实现了Per接口的所有类。 Performer作为实际实现者。下面我们来个借《Java与模式》的例子，来整体理解一下简单工厂设计模式。 

如果有一个农场，负责销售各种水果，你作为一个客户，只需要对农场的销售人员说：我要苹果，农场就会给你苹果。

转换成软件语言： 农场是个服务端，而他对外的接口便是销售人员，客户便是客户端。  客户端只需要知道Fruit和 工厂类，就可以得到期望的水果，比如苹果，而不需要知道其他苹果或者葡萄的实现类。

水果接口

1. public interface Fruit{  
2.  
3. void grow();  
4.  
5. void harvest();  
6.  
7. void plant();  
8.  
9. }  
10.  

苹果实现类

1. /** * 苹果
2. */
3. public class Apple implements Fruit{  
4.   private int treeAge;  
5.   public void grow(){  
6.     log("apple grow");  
7.   }  
8.   public void harvest(){  
9.     log("apple harvest");  
10.   }  
11.   public void plant(){  
12.     log("apple plant");  
13.   }  
14.   public void log(String msg){  
15.     System.out.println(msg);  
16.   }  
17.  
18. }  

然后还有葡萄和草莓类，我就略了。

下面我们编写工厂类

1. pulibc class FruitFactory{  
2.  
3.     public static Fruit factory(String which){  
4.       if(which.equalsIgnoreCase("apple")){  
5.         return new Apple();  
6.      }else if(which.equalsIgnoreCase("strawberry")){  
7.         return new Strawberry()  
8.      }else if(which.equalsIgnoreCase("grape")){  
9.         return new Grape();  
10.      }  
11.      else {  
12.       throw new BadFrutException("Bad fruit request!")  
13.     //如果编写的自己 的组件，试着定义自己的异常基类  
14.       }  
15.    }  
16. }  
17.  

 看看客户端需要做的：  

1. FruitFactory.factory("apple"); 

 如果不这么做，客户端要得到一个苹果，那么需要:

1. new Apple() 

那么再要点草莓：

1. new Strawberry（） 

好的，我是服务器，我忽然想升级了，我觉得Apple这个名字，应该改名叫AppleRed. 于是加了一个新类，并且兼容原来的版本，在服务器并没有一个好的设计，我不得不保留了Apple这个类。

客户端：我因为你的升级，而要改变原来的代码，这太可怕了。

 再看看服务器端用了工厂模式的好处

服务器： 平滑升级，不需要发布新的API告知客户我做了什么。

客户端： 什么都不需要做。 

何时用简单工厂模式：

如上面的例子：一般客户端和服务端的形式的情况，或者编写插件情况下，喜欢采用简单工厂方法。

实际应用：

1. spring 中有用到简单工厂模式

2. 抽象工厂模式 经常用到 简单工厂模式

有点晚了，抽象工厂和工厂方法相对复杂，容易弄混，下篇文章再介绍。