JAVA几种常见的设计模式

1、工厂方法模式（Factory Method）

工厂方法模式分为三种：

11、普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。首先看下关系图：

举例如下：（我们举一个发送邮件和短信的例子）

首先，创建二者的共同接口：

[java]  view plain  copy

1. public interface Sender {  
2.     public void Send();  
3. }  

其次，创建实现类：

[java]  view plain  copy

1. public class MailSender implements Sender {  
2.     @Override  
3.     public void Send() {  
4.         System.out.println("this is mailsender!");  
5.     }  
6. }  

[java]  view plain  copy

1. public class SmsSender implements Sender {  
2.   
3.     @Override  
4.     public void Send() {  
5.         System.out.println("this is sms sender!");  
6.     }  
7. }  

最后，建工厂类：

[java]  view plain  copy

1. public class SendFactory {  
2.   
3.     public Sender produce(String type) {  
4.         if ("mail".equals(type)) {  
5.             return new MailSender();  
6.         } else if ("sms".equals(type)) {  
7.             return new SmsSender();  
8.         } else {  
9.             System.out.println("请输入正确的类型!");  
10.             return null;  
11.         }  
12.     }  
13. }  

我们来测试下：

[java]  view plain  copy

1. public class FactoryTest {  
2.   
3.     public static void main(String[] args) {  
4.         SendFactory factory = new SendFactory();  
5.         Sender sender = factory.produce("sms");  
6.         sender.Send();  
7.     }  
8. }  

输出：this is sms sender!

22、多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。关系图：

将上面的代码做下修改，改动下SendFactory类就行，如下：

[java]  view plain  copy

1. public class SendFactory {  
2.       
3.     public Sender produceMail(){  
4.         return new MailSender();  
5.     }  
6.       
7.     public Sender produceSms(){  
8.         return new SmsSender();  
9.     }  
10. }  

测试类如下：

[java]  view plain  copy

1. public class FactoryTest {  
2.   
3.     public static void main(String[] args) {  
4.         SendFactory factory = new SendFactory();  
5.         Sender sender = factory.produceMail();  
6.         sender.Send();  
7.     }  
8. }  

输出：this is mailsender!

33、静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

[java]  view plain  copy

1. public class SendFactory {  
2.       
3.     public static Sender produceMail(){  
4.         return new MailSender();  
5.     }  
6.       
7.     public static Sender produceSms(){  
8.         return new SmsSender();  
9.     }  
10. }  

[java]  view plain  copy

1. public class FactoryTest {  
2.   
3.     public static void main(String[] args) {      
4.         Sender sender = SendFactory.produceMail();  
5.         sender.Send();  
6.     }  
7. }  

输出：this is mailsender!

总体来说，工厂模式适合：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。

2、抽象工厂模式（Abstract Factory）

工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。因为抽象工厂不太好理解，我们先看看图，然后就和代码，就比较容易理解。

请看例子：

[java]  view plain  copy

1. public interface Sender {  
2.     public void Send();  
3. }  

两个实现类：

[java]  view plain  copy

1. public class MailSender implements Sender {  
2.     @Override  
3.     public void Send() {  
4.         System.out.println("this is mailsender!");  
5.     }  
6. }  

[java]  view plain  copy

1. public class SmsSender implements Sender {  
2.   
3.     @Override  
4.     public void Send() {  
5.         System.out.println("this is sms sender!");  
6.     }  
7. }  

两个工厂类：

[java]  view plain  copy

1. public class SendMailFactory implements Provider {  
2.       
3.     @Override  
4.     public Sender produce(){  
5.         return new MailSender();  
6.     }  
7. }  

[java]  view plain  copy

1. public class SendSmsFactory implements Provider{  
2.   
3.     @Override  
4.     public Sender produce() {  
5.         return new SmsSender();  
6.     }  
7. }  

在提供一个接口：

[java]  view plain  copy

1. public interface Provider {  
2.     public Sender produce();  
3. }  

测试类：

[java]  view plain  copy

1. public class Test {  
2.   
3.     public static void main(String[] args) {  
4.         Provider provider = new SendMailFactory();  
5.         Sender sender = provider.produce();  
6.         sender.Send();  
7.     }  
8. }  

其实这个模式的好处就是，如果你现在想增加一个功能：发及时信息，则只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口，就OK了，无需去改动现成的代码。这样做，拓展性较好！

3、单例模式（Singleton）

单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：

1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。

2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。

3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

首先我们写一个简单的单例类：

[java]  view plain  copy

1. public class Singleton {  
2.   
3.     /* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */  
4.     private static Singleton instance = null;  
5.   
6.     /* 私有构造方法，防止被实例化 */  
7.     private Singleton() {  
8.     }  
9.   
10.     /* 静态工程方法，创建实例 */  
11.     public static Singleton getInstance() {  
12.         if (instance == null) {  
13.             instance = new Singleton();  
14.         }  
15.         return instance;  
16.     }  
17.   
18.     /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */  
19.     public Object readResolve() {  
20.         return instance;  
21.     }  
22. }  

这个类可以满足基本要求，但是，像这样毫无线程安全保护的类，如果我们把它放入多线程的环境下，肯定就会出现问题了，如何解决？我们首先会想到对getInstance方法加synchronized关键字，如下：

[java]  view plain  copy

1. public static synchronized Singleton getInstance() {  
2.         if (instance == null) {  
3.             instance = new Singleton();  
4.         }  
5.         return instance;  
6.     }  

但是，synchronized关键字锁住的是这个对象，这样的用法，在性能上会有所下降，因为每次调用getInstance()，都要对对象上锁，事实上，只有在第一次创建对象的时候需要加锁，之后就不需要了，所以，这个地方需要改进。我们改成下面这个：

[java]  view plain  copy

1. public static Singleton getInstance() {  
2.         if (instance == null) {  
3.             synchronized (instance) {  
4.                 if (instance == null) {  
5.                     instance = new Singleton();  
6.                 }  
7.             }  
8.         }  
9.         return instance;  
10.     }  

似乎解决了之前提到的问题，将synchronized关键字加在了内部，也就是说当调用的时候是不需要加锁的，只有在instance为null，并创建对象的时候才需要加锁，性能有一定的提升。但是，这样的情况，还是有可能有问题的，看下面的情况：在Java指令中创建对象和赋值操作是分开进行的，也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，然后再去初始化这个Singleton实例。这样就可能出错了，我们以A、B两个线程为例：

a>A、B线程同时进入了第一个if判断

b>A首先进入synchronized块，由于instance为null，所以它执行instance = new Singleton();

c>由于JVM内部的优化机制，JVM先画出了一些分配给Singleton实例的空白内存，并赋值给instance成员（注意此时JVM没有开始初始化这个实例），然后A离开了synchronized块。

d>B进入synchronized块，由于instance此时不是null，因此它马上离开了synchronized块并将结果返回给调用该方法的程序。

e>此时B线程打算使用Singleton实例，却发现它没有被初始化，于是错误发生了。

所以程序还是有可能发生错误，其实程序在运行过程是很复杂的，从这点我们就可以看出，尤其是在写多线程环境下的程序更有难度，有挑战性。我们对该程序做进一步优化：

[java]  view plain  copy

1. private static class SingletonFactory{           
2.         private static Singleton instance = new Singleton();           
3.     }           
4.     public static Singleton getInstance(){           
5.         return SingletonFactory.instance;           
6.     }   

实际情况是，单例模式使用内部类来维护单例的实现，JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，并且会保证把赋值给instance的内存初始化完毕，这样我们就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低性能问题。这样我们暂时总结一个完美的单例模式：

[java]  view plain  copy

1. public class Singleton {  
2.   
3.     /* 私有构造方法，防止被实例化 */  
4.     private Singleton() {  
5.     }  
6.   
7.     /* 此处使用一个内部类来维护单例 */  
8.     private static class SingletonFactory {  
9.         private static Singleton instance = new Singleton();  
10.     }  
11.   
12.     /* 获取实例 */  
13.     public static Singleton getInstance() {  
14.         return SingletonFactory.instance;  
15.     }  
16.   
17.     /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */  
18.     public Object readResolve() {  
19.         return getInstance();  
20.     }  
21. }  

其实说它完美，也不一定，如果在构造函数中抛出异常，实例将永远得不到创建，也会出错。所以说，十分完美的东西是没有的，我们只能根据实际情况，选择最适合自己应用场景的实现方法。也有人这样实现：因为我们只需要在创建类的时候进行同步，所以只要将创建和getInstance()分开，单独为创建加synchronized关键字，也是可以的：

[java]  view plain  copy

1. public class SingletonTest {  
2.   
3.     private static SingletonTest instance = null;  
4.   
5.     private SingletonTest() {  
6.     }  
7.   
8.     private static synchronized void syncInit() {  
9.         if (instance == null) {  
10.             instance = new SingletonTest();  
11.         }  
12.     }  
13.   
14.     public static SingletonTest getInstance() {  
15.         if (instance == null) {  
16.             syncInit();  
17.         }  
18.         return instance;  
19.     }  
20. }  

考虑性能的话，整个程序只需创建一次实例，所以性能也不会有什么影响。

补充：采用"影子实例"的办法为单例对象的属性同步更新

[java]  view plain  copy

1. public class SingletonTest {  
2.   
3.     private static SingletonTest instance = null;  
4.     private Vector properties = null;  
5.   
6.     public Vector getProperties() {  
7.         return properties;  
8.     }  
9.   
10.     private SingletonTest() {  
11.     }  
12.   
13.     private static synchronized void syncInit() {  
14.         if (instance == null) {  
15.             instance = new SingletonTest();  
16.         }  
17.     }  
18.   
19.     public static SingletonTest getInstance() {  
20.         if (instance == null) {  
21.             syncInit();  
22.         }  
23.         return instance;  
24.     }  
25.   
26.     public void updateProperties() {  
27.         SingletonTest shadow = new SingletonTest();  
28.         properties = shadow.getProperties();  
29.     }  
30. }  

通过单例模式的学习告诉我们：

1、单例模式理解起来简单，但是具体实现起来还是有一定的难度。

2、synchronized关键字锁定的是对象，在用的时候，一定要在恰当的地方使用（注意需要使用锁的对象和过程，可能有的时候并不是整个对象及整个过程都需要锁）。

到这儿，单例模式基本已经讲完了，结尾处，笔者突然想到另一个问题，就是采用类的静态方法，实现单例模式的效果，也是可行的，此处二者有什么不同？

首先，静态类不能实现接口。（从类的角度说是可以的，但是那样就破坏了静态了。因为接口中不允许有static修饰的方法，所以即使实现了也是非静态的）

其次，单例可以被延迟初始化，静态类一般在第一次加载是初始化。之所以延迟加载，是因为有些类比较庞大，所以延迟加载有助于提升性能。

再次，单例类可以被继承，他的方法可以被覆写。但是静态类内部方法都是static，无法被覆写。

最后一点，单例类比较灵活，毕竟从实现上只是一个普通的Java类，只要满足单例的基本需求，你可以在里面随心所欲的实现一些其它功能，但是静态类不行。从上面这些概括中，基本可以看出二者的区别，但是，从另一方面讲，我们上面最后实现的那个单例模式，内部就是用一个静态类来实现的，所以，二者有很大的关联，只是我们考虑问题的层面不同罢了。两种思想的结合，才能造就出完美的解决方案，就像HashMap采用数组+链表来实现一样，其实生活中很多事情都是这样，单用不同的方法来处理问题，总是有优点也有缺点，最完美的方法是，结合各个方法的优点，才能最好的解决问题！

4、装饰者模式

这个模式花费了挺长时间，开始有点难理解，其实就是

定义：动态给一个对象添加一些额外的职责,就象在墙上刷油漆.使用Decorator模式相比用生成子类方式达到功能的扩充显得更为灵活。
设计初衷:通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势必生成很多子类,增加系统的复杂性,同时,使用继承实现功能拓展,我们必须可预见这些拓展功能,这些功能是编译时就确定了,是静态的。

 

 要点：装饰者与被装饰者拥有共同的超类，继承的目的是继承类型，而不是行为

   实际上Java 的I/O API就是使用Decorator实现的。

 

[java]  view plain  copy

 print ?

1. //定义被装饰者  
2. public interface Human {  
3.     public void wearClothes();  
4.   
5.     public void walkToWhere();  
6. }  
7.   
8. //定义装饰者  
9. public abstract class Decorator implements Human {  
10.     private Human human;  
11.   
12.     public Decorator(Human human) {  
13.         this.human = human;  
14.     }  
15.   
16.     public void wearClothes() {  
17.         human.wearClothes();  
18.     }  
19.   
20.     public void walkToWhere() {  
21.         human.walkToWhere();  
22.     }  
23. }  
24.   
25. //下面定义三种装饰，这是第一个，第二个第三个功能依次细化，即装饰者的功能越来越多  
26. public class Decorator_zero extends Decorator {  
27.   
28.     public Decorator_zero(Human human) {  
29.         super(human);  
30.     }  
31.   
32.     public void goHome() {  
33.         System.out.println("进房子。。");  
34.     }  
35.   
36.     public void findMap() {  
37.         System.out.println("书房找找Map。。");  
38.     }  
39.   
40.     @Override  
41.     public void wearClothes() {  
42.         // TODO Auto-generated method stub  
43.         super.wearClothes();  
44.         goHome();  
45.     }  
46.   
47.     @Override  
48.     public void walkToWhere() {  
49.         // TODO Auto-generated method stub  
50.         super.walkToWhere();  
51.         findMap();  
52.     }  
53. }  
54.   
55. public class Decorator_first extends Decorator {  
56.   
57.     public Decorator_first(Human human) {  
58.         super(human);  
59.     }  
60.   
61.     public void goClothespress() {  
62.         System.out.println("去衣柜找找看。。");  
63.     }  
64.   
65.     public void findPlaceOnMap() {  
66.         System.out.println("在Map上找找。。");  
67.     }  
68.   
69.     @Override  
70.     public void wearClothes() {  
71.         // TODO Auto-generated method stub  
72.         super.wearClothes();  
73.         goClothespress();  
74.     }  
75.   
76.     @Override  
77.     public void walkToWhere() {  
78.         // TODO Auto-generated method stub  
79.         super.walkToWhere();  
80.         findPlaceOnMap();  
81.     }  
82. }  
83.   
84. public class Decorator_two extends Decorator {  
85.   
86.     public Decorator_two(Human human) {  
87.         super(human);  
88.     }  
89.   
90.     public void findClothes() {  
91.         System.out.println("找到一件D&G。。");  
92.     }  
93.   
94.     public void findTheTarget() {  
95.         System.out.println("在Map上找到神秘花园和城堡。。");  
96.     }  
97.   
98.     @Override  
99.     public void wearClothes() {  
100.         // TODO Auto-generated method stub  
101.         super.wearClothes();  
102.         findClothes();  
103.     }  
104.   
105.     @Override  
106.     public void walkToWhere() {  
107.         // TODO Auto-generated method stub  
108.         super.walkToWhere();  
109.         findTheTarget();  
110.     }  
111. }  
112.   
113. //定义被装饰者，被装饰者初始状态有些自己的装饰  
114. public class Person implements Human {  
115.   
116.     @Override  
117.     public void wearClothes() {  
118.         // TODO Auto-generated method stub  
119.         System.out.println("穿什么呢。。");  
120.     }  
121.   
122.     @Override  
123.     public void walkToWhere() {  
124.         // TODO Auto-generated method stub  
125.         System.out.println("去哪里呢。。");  
126.     }  
127. }  
128. //测试类，看一下你就会发现，跟java的I/O操作有多么相似  
129. public class Test {  
130.     public static void main(String[] args) {  
131.         Human person = new Person();  
132.         Decorator decorator = new Decorator_two(new Decorator_first(  
133.                 new Decorator_zero(person)));  
134.         decorator.wearClothes();  
135.         decorator.walkToWhere();  
136.     }  
137. }  

运行结果：

其实就是进房子找衣服，然后找地图这样一个过程，通过装饰者的三层装饰，把细节变得丰富。

关键点：
1、Decorator抽象类中，持有Human接口，方法全部委托给该接口调用，目的是交给该接口的实现类即子类进行调用。
2、Decorator抽象类的子类（具体装饰者），里面都有一个构造方法调用super(human),这一句就体现了抽象类依赖于子类实现即抽象依赖于实现的原则。因为构造里面参数都是Human接口，只要是该Human的实现类都可以传递进去，即表现出Decorator dt = new Decorator_second(new Decorator_first(new Decorator_zero(human)));这种结构的样子。所以当调用dt.wearClothes();dt.walkToWhere()的时候，又因为每个具体装饰者类中，都先调用super.wearClothes和super.walkToWhere()方法，而该super已经由构造传递并指向了具体的某一个装饰者类（这个可以根据需要调换顺序），那么调用的即为装饰类的方法，然后才调用自身的装饰方法，即表现出一种装饰、链式的类似于过滤的行为。
3、具体被装饰者类，可以定义初始的状态或者初始的自己的装饰，后面的装饰行为都在此基础上一步一步进行点缀、装饰。
4、装饰者模式的设计原则为：对扩展开放、对修改关闭，这句话体现在我如果想扩展被装饰者类的行为，无须修改装饰者抽象类，只需继承装饰者抽象类，实现额外的一些装饰或者叫行为即可对被装饰者进行包装。所以：扩展体现在继承、修改体现在子类中，而不是具体的抽象类，这充分体现了依赖倒置原则，这是自己理解的装饰者模式。

说的不清楚，有些只可意会不可言传的感觉，多看几遍代码，然后自己敲出来运行一下，基本上就领悟了。

下面这个例子也有助于理解 装饰的流程和作用

现在需要一个汉堡，主体是鸡腿堡，可以选择添加生菜、酱、辣椒等等许多其他的配料，这种情况下就可以使用装饰者模式。

汉堡基类（被装饰者，相当于上面的Human）

[java]  view plain  copy

 print ?

1. package decorator;    
2.     
3. public abstract class Humburger {    
4.         
5.     protected  String name ;    
6.         
7.     public String getName(){    
8.         return name;    
9.     }    
10.         
11.     public abstract double getPrice();    
12.     
13. }    

鸡腿堡类（被装饰者的初始状态，有些自己的简单装饰，相当于上面的Person）

[java]  view plain  copy

 print ?

1. package decorator;    
2.     
3. public class ChickenBurger extends Humburger {    
4.         
5.     public ChickenBurger(){    
6.         name = "鸡腿堡";    
7.     }    
8.     
9.     @Override    
10.     public double getPrice() {    
11.         return 10;    
12.     }    
13.     
14. }    

配料的基类（装饰者，用来对汉堡进行多层装饰，每层装饰增加一些配料，相当于上面Decorator）

[java]  view plain  copy

 print ?

1. package decorator;    
2.     
3. public abstract class Condiment extends Humburger {    
4.         
5.     public abstract String getName();    
6.     
7. }    

 

生菜（装饰者的第一层，相当于上面的decorator_zero）

[java]  view plain  copy

 print ?

1. package decorator;    
2.     
3. public class Lettuce extends Condiment {    
4.         
5.     Humburger humburger;    
6.         
7.     public Lettuce(Humburger humburger){    
8.         this.humburger = humburger;    
9.     }    
10.     
11.     @Override    
12.     public String getName() {    
13.         return humburger.getName()+" 加生菜";    
14.     }    
15.     
16.     @Override    
17.     public double getPrice() {    
18.         return humburger.getPrice()+1.5;    
19.     }    
20.     
21. }    

辣椒（装饰者的第二层，相当于上面的decorator_first）

[java]  view plain  copy

 print ?

1. package decorator;    
2.     
3. public class Chilli extends Condiment {    
4.         
5.     Humburger humburger;    
6.         
7.     public Chilli(Humburger humburger){    
8.         this.humburger = humburger;    
9.             
10.     }    
11.     
12.     @Override    
13.     public String getName() {    
14.         return humburger.getName()+" 加辣椒";    
15.     }    
16.     
17.     @Override    
18.     public double getPrice() {    
19.         return humburger.getPrice();  //辣椒是免费的哦    
20.     }    
21.     
22. }    

测试类

[java]  view plain  copy

 print ?

1. package decorator;    
2.     
3. public class Test {    
4.     
5.     /**  
6.      * @param args  
7.      */    
8.     public static void main(String[] args) {    
9.         Humburger humburger = new ChickenBurger();    
10.         System.out.println(humburger.getName()+"  价钱："+humburger.getPrice());    
11.         Lettuce lettuce = new Lettuce(humburger);    
12.         System.out.println(lettuce.getName()+"  价钱："+lettuce.getPrice());    
13.         Chilli chilli = new Chilli(humburger);    
14.         System.out.println(chilli.getName()+"  价钱："+chilli.getPrice());    
15.         Chilli chilli2 = new Chilli(lettuce);    
16.         System.out.println(chilli2.getName()+"  价钱："+chilli2.getPrice());    
17.     }    
18.     
19. }    

输出

[java]  view plain  copy

 print ?

1. 鸡腿堡  价钱：10.0    
2. 鸡腿堡 加生菜  价钱：11.5    
3. 鸡腿堡 加辣椒  价钱：10.0    
4. 鸡腿堡 加生菜 加辣椒  价钱：11.5    

5、代理模式：

1，什么是代理模式？

代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。

 

2，策略模式有什么好处？

    在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

 

3，代理模式一般涉及到的角色有：

 

抽象角色：声明真实对象和代理对象的共同接口； 

代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。 

真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。

 

 

4，应用场景举例：

 

比如西门庆找潘金莲，那潘金莲不好意思答复呀，咋办，找那个王婆做代理，表现在程序上时是这样的体现的

先说说这个场景中的要素：一种类型的女人，潘金莲，王婆，西门庆，后来扩展的贾氏也和西门庆勾上了，我们是假设的，然后西门庆找潘金莲happy,但潘金莲不好意思直接，就找个王婆代理呗。我们看看具体代码。

 

先定义一种女人

Java代码  

1. package com.yangguangfu.proxy;  
2. /** 
3.  *  
4.  * @author 阿福(trygf521@126.com)<br> 
5.  *定义一种类型的女人，王婆和潘金莲都属于这个类型的女人 
6.  */  
7. public interface KindWoman {  
8.       
9.     //这种女人能做什么事情呢？  
10.     public void makeEyesWithMan();//抛媚眼  
11.       
12.     public void happyWithMan();//和男人那个....  
13.   
14. }  

 

一种类型嘛，那肯定是接口，定义个潘金莲

Java代码  

1. package com.yangguangfu.proxy;  
2. /** 
3.  *  
4.  * @author 阿福(trygf521@126.com)<br> 
5.  *定义一个潘金莲是什么样的人 
6.  */  
7. public class PanJinLian  implements KindWoman{  
8.   
9.     @Override  
10.     public void happyWithMan() {  
11.         System.out.println("潘金莲和男人在做那个...");  
12.           
13.     }  
14.   
15.     @Override  
16.     public void makeEyesWithMan() {  
17.         System.out.println("潘金莲抛媚眼...");  
18.           
19.     }  
20.   
21. }  

 

再定义个丑陋的王婆

Java代码  

1. package com.yangguangfu.proxy;  
2. /** 
3.  *  
4.  * @author 阿福(trygf521@126.com)<br> 
5.  *王婆这个人老聪明了，她太老了，是个男人都看不上她， 
6.  *但是她有智慧经验呀，他作为一类女人的代理！ 
7.  */  
8. public class WangPo implements KindWoman {  
9.       
10.     private KindWoman kindWoman;  
11.       
12.     public WangPo(){  
13.         //默认的话是潘金莲的代理  
14.         this.kindWoman = new PanJinLian();  
15.     }  
16.     //她可以是KindWomam的任何一个女人的代理，只要你是这一类型  
17.     public WangPo(KindWoman kindWoman){  
18.         this.kindWoman = kindWoman;  
19.     }  
20.   
21.     @Override  
22.     public void happyWithMan() {  
23.         //自己老了，干不了了，但可以叫年轻的代替。  
24.         this.kindWoman.happyWithMan();  
25.           
26.     }  
27.   
28.     @Override  
29.     public void makeEyesWithMan() {  
30.         //王婆年纪大了，谁看她抛媚眼啊  
31.         this.kindWoman.makeEyesWithMan();  
32.           
33.     }  
34.   
35. }  

 

两个女主角都上场了，该男主角了，定义个西门庆

Java代码  

1. package com.yangguangfu.proxy;  
2. /** 
3.  *  
4.  * @author 阿福(trygf521@126.com)<br> 
5.  *水浒传是这样写的：西门庆被潘金莲用竹竿敲了一下，西门庆看痴迷了，被王婆看到了，就开始撮合两人好事，王婆作为潘金莲的代理人收了不少好处费，那我们假设一下： 
6.  *如果没有王婆在中间牵线，这两个不要脸的能成事吗？难说得很！ 
7.  */  
8. public class XiMenQiang {  
9.   
10.     /** 
11.      * @param args 
12.      */  
13.     public static void main(String[] args) {  
14.         WangPo wangPo;  
15.         //把王婆叫出来  
16.          wangPo = new WangPo();  
17.         //然后西门庆说，我要和潘金莲Happy,然后王婆就安排了西门庆丢筷子哪出戏：  
18.         wangPo.makeEyesWithMan();  
19.         //看到没有表面是王婆在做，其实爽的是潘金莲  
20.         wangPo.happyWithMan();  
21.           
22.           
23.   
24.     }  
25.   
26. }  

 

那这就是活生生的一个例子，通过代理人实现了某种目的，如果真去了王婆这个中间环节，直接西门庆和潘金莲勾搭，估计很难成就武松杀嫂事件。

     那我们再考虑一下，水浒里面还有没有这类型的女人？有，卢俊义的老婆贾氏（就是和那个管家苟合的那个），这个名字起的：“贾氏”，那我们也让王婆做她的代理：

Java代码  

1. package com.yangguangfu.proxy;  
2. /** 
3.  *  
4.  * @author 阿福(trygf521@126.com)<br> 
5.  *定义一个贾氏是什么样的人 
6.  */  
7. public class JiaShi implements KindWoman {  
8.   
9.     @Override  
10.     public void happyWithMan() {  
11.         System.out.println("贾氏和男人在做那个...");  
12.           
13.     }  
14.   
15.     @Override  
16.     public void makeEyesWithMan() {  
17.         System.out.println("贾氏抛媚眼...");  
18.           
19.     }  
20.   
21.   
22. }  

 

西门庆勾潘金莲又勾引贾氏

Java代码  

1. package com.yangguangfu.proxy;  
2. /** 
3.  *  
4.  * @author 阿福(trygf521@126.com)<br> 
5.  *水浒传是这样写的：西门庆被潘金莲用竹竿敲了一下，西门庆看痴迷了，被王婆看到了，就开始撮合两人好事，王婆作为潘金莲的代理人收了不少好处费，那我们假设一下： 
6.  *如果没有王婆在中间牵线，这两个不要脸的能成事吗？难说得很！ 
7.  */  
8. public class XiMenQiang {  
9.   
10.     /** 
11.      * @param args 
12.      */  
13.     public static void main(String[] args) {  
14.         WangPo wangPo;  
15.         //把王婆叫出来  
16.          wangPo = new WangPo();  
17.         //然后西门庆说，我要和潘金莲Happy,然后王婆就安排了西门庆丢筷子哪出戏：  
18.         wangPo.makeEyesWithMan();  
19.         //看到没有表面是王婆在做，其实爽的是潘金莲  
20.         wangPo.happyWithMan();  
21.           
22.           
23.           
24.         //西门庆勾引贾氏  
25.         JiaShi jiaShi = new JiaShi();  
26.         wangPo = new WangPo(jiaShi);  
27.         wangPo.makeEyesWithMan();  
28.         wangPo.happyWithMan();  
29.   
30.     }  
31.   
32. }  

 说完这个故事，那我总结一下，代理模式主要使用了java的多态，干活的是被代理类，代理类主要是接活，你让我干活，好，我交给幕后的类去干，你满意就成，那怎么知道被代理类能不能干呢？同根就成，大家知根知底，你能做啥，我能做啥都清楚得很，同样一个接口呗。好了不多说了，慢慢体会吧。