设计模式：策略、代理、单例

一. 策略模式

定义：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

先说这个场景中的要素：三个妙计，一个锦囊，一个赵云。

1）妙计：(一个接口，三个具体妙计)

1 package com.henry.strategy;
2
3 public interface IStrategy {
4
5     public void operate();
6
7 }

IStrategy.java

 1 package com.henry.strategy;
 2
 3 public class BackDoor implements IStrategy {
 4
 5     @Override
 6     public void operate() {
 7         // TODO Auto-generated method stub
 8         System.out.println("找乔国老帮忙，让吴国太给孙权施加压力");
 9     }
10
11 }

BackDoor.java

 1 package com.henry.strategy;
 2
 3 public class GivenGreenLight implements IStrategy {
 4
 5     @Override
 6     public void operate() {
 7         // TODO Auto-generated method stub
 8         System.out.println("求吴国太开个绿灯,放行！");
 9     }
10
11 }

GivenGreenLight.java

 1 package com.henry.strategy;
 2
 3 public class BlockEnemy implements IStrategy {
 4
 5     @Override
 6     public void operate() {
 7         // TODO Auto-generated method stub
 8         System.out.println("孙夫人断后，挡住追兵");
 9     }
10
11 }

BlockEnemy.java

2）接下来就是锦囊了，用来放妙计的东东。

 1 package com.henry.strategy;
 2
 3 public class Context {
 4
 5     private IStrategy strategy;
 6
 7     public Context(IStrategy strategy) {
 8         this.strategy = strategy;
 9     }
10
11     public void operate() {
12         this.strategy.operate();
13     }
14 }

Context.java

3) 最后就是赵子龙登场的时候了。

 1 package com.henry.strategy;
 2
 3 public class ZhaoYun {
 4
 5     public static void main(String[] args) {
 6         Context context;
 7
 8         //刚刚到吴国的时候拆第一个
 9         System.out.println("-----------刚刚到吴国的时候拆第一个-------------");
10         context = new Context(new BackDoor()); //拿到妙计
11         context.operate(); //拆开执行
12         System.out.println("");
13
14         //刘备乐不思蜀了，拆第二个了
15         System.out.println("-----------刘备乐不思蜀了，拆第二个了-------------");
16         context = new Context(new GivenGreenLight());
17         context.operate(); //执行了第二个锦囊了
18         System.out.println("");
19
20         //孙权的小兵追了，咋办？拆第三个
21         System.out.println("-----------孙权的小兵追了，咋办？拆第三个-------------");
22         context = new Context(new BlockEnemy());
23         context.operate(); //孙夫人退兵
24         System.out.println("");
25     }
26
27 }

ZhaoYun.java

二. 代理模式
定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

场景：比如西门庆找潘金莲，那潘金莲不好意思答复呀，咋办，找那个王婆做代理，表现在程序上时这样的：
1) 先定义一种类型的女人：

1 package com.henry.proxy;
2
3 public interface KindWomen {
4
5     public void makeEyesWithMan();
6     public void happyWithMan();
7
8 }

KindWomen.java

2) 再定一个丑陋的王婆：

 1 package com.henry.proxy;
 2
 3 public class WangPo implements KindWomen {
 4
 5     private KindWomen kindWomen;
 6
 7     public WangPo() {
 8         this.kindWomen = new PanJinLian();
 9     }
10
11     public WangPo(KindWomen kindWomen) {
12         this.kindWomen = kindWomen;
13     }
14
15     @Override
16     public void makeEyesWithMan() {
17         // TODO Auto-generated method stub
18         this.kindWomen.makeEyesWithMan();
19     }
20
21     @Override
22     public void happyWithMan() {
23         // TODO Auto-generated method stub
24         this.kindWomen.happyWithMan();
25     }
26
27 }

WangPo.java

3) 两个女主角都上场了，男主角也该出现了：

 1 package com.henry.proxy;
 2
 3 public class XiMenQing {
 4
 5     public static void main(String[] args) {
 6         WangPo wangPo = new WangPo();
 7
 8         wangPo.makeEyesWithMan();
 9         wangPo.happyWithMan();
10     }
11
12 }

XiMenQing.java

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

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

4）把贾氏素描出来：

 1 package com.henry.proxy;
 2
 3 public class JiaShi implements KindWomen {
 4
 5     @Override
 6     public void makeEyesWithMan() {
 7         // TODO Auto-generated method stub
 8         System.out.println("贾氏抛媚眼");
 9     }
10
11     @Override
12     public void happyWithMan() {
13         // TODO Auto-generated method stub
14         System.out.println("贾氏正在happy中......");
15     }
16
17 }

JiaShi

5) 西门庆勾贾氏:

 1 package com.henry.proxy;
 2
 3 public class XiMenQing2 {
 4
 5     public static void main(String[] args) {
 6         JiaShi jiaShi = new JiaShi();
 7         WangPo wangPo = new WangPo(jiaShi);
 8
 9         wangPo.makeEyesWithMan();
10         wangPo.happyWithMan();
11     }
12
13 }

XiMenQing2.java

(1).职责清晰

真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理完成一件完成事务，附带的结果就是编程简洁清晰。

(2).代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了的作用和保护了目标对象的作用。

(3).高扩展性

三. 单例模式

 1 package com.henry.singleton;
 2
 3 public class Emperor {
 4     private static Emperor emperor = null;
 5
 6     private Emperor() {
 7     }
 8
 9     public static Emperor getInstance() {
10         if(emperor == null) {
11             emperor = new Emperor();
12         }
13         return emperor;
14     }
15
16     public static void emperorInfo(){
17         System.out.println("我就是皇帝asdasdsdssd");
18     }
19 }

Emperor.java

 1 package com.henry.singleton;
 2
 3 public class Minister {
 4     public static void main(String[] args) {
 5         //First Day
 6         Emperor emperor1 = Emperor.getInstance();
 7         emperor1.emperorInfo();
 8
 9         //Second day
10         Emperor emperor2 = Emperor.getInstance();
11         emperor2.emperorInfo();
12
13         //Third day
14         Emperor emperor3 = Emperor.getInstance();
15         emperor3.emperorInfo();
16     }
17 }

Minister.java