杀人中的技术

 

古往今来，杀手无数，杀人手段也是千奇百怪，从荆轲的直接用刀捅到《这个杀手不太冷》里面的狙击枪，甚至直接用伞碰你一下你都会挂的杀人手段，真是令人大开眼界，但是我今天要说的不是如何如何杀人，也不是怎样玩杀人游戏，而是我要说的设计模式之－Bridge设计模式。<o:p></o:p>

在面向对象设计的基本概念中，对象这个概念实际是由属性和行为两个部分组成的，属性我们可以认为是一种静止的，是一种抽象，一般情况下，行为是包含在一个对象中，但是，在有的情况下，我们需要将这些行为也进行归类，形成一个总的行为接口，这就是桥模式的用处<o:p></o:p>

面向对象的编程就是把我们把需要做的事情合理的抽象化，最大化的适应变化。看看上面说的杀手，“杀手”是一个集合名词，代表着一类人。佣金高，技术好的我们叫他“职业杀手”；佣金一半，杀人手段一般，我们叫“普通杀手”；而那些笨笨的，完全是一时冲动的杀手还没杀着人就被对手打晕了我们叫他“愚蠢杀手”，这类杀手甚至有点搞笑的含义：）。这些杀手为什么这么去分类，完全取决于他们的技术高低，而不管他们用什么手段去杀（即使用一根草，高手也可以快速置人于死地）。这个潜在的所谓技术就是他们本质的区别，当然成为我们区别他们的标准，而如何杀人仅仅是他们的行为而已。<o:p></o:p>

现在可以看清一点了，对于对象而言，属性是它的静态特征，而行为是他的动态特征，有时候我们不仅仅需要把特征抽象出来，而且需要把行为抽象出来，比如：对于杀手，技术的高低可以将他们进行分类，这是一个属性的抽象，而杀人手段千奇百怪，这是一个行为的抽象。<o:p></o:p>

现在言归正传，有上面三类杀手，而杀人手段暂定为“枪杀”，“火杀”两种我们应该如何去设计杀手这个类。<o:p></o:p>

1．  显然“杀手”是基类，三类杀手是子类<o:p></o:p>

2．  杀手杀人这个动作显然可以通过多种手段完成，好吧，也是一个抽象，这个是行为的抽象。<o:p></o:p>

我是这么设计的：<o:p></o:p>

<o:p></o:p>

java 代码

1. 杀手类   
2. /**  
3.  * 杀手的封装类  
4.  * @author zxy  
5.  *  
6.  */  
7. public abstract class Killer   
8. {    
9.     private Kill killOperation;   
10.     public Killer(Kill killOperation )   
11.     {   
12.         this.killOperation=killOperation;   
13.     }   
14.     public abstract void doKill();   
15.     public Kill getKillOperation()   
16.     {   
17.         return killOperation;   
18.     }   
19.   
20. 杀人   
21. /**  
22.  * 杀人的动作，抽象为一个接口  
23.  * @author zxy  
24.  *  
25.  */  
26. public interface Kill   
27. {   
28.   public void kill();   
29. }   
30. }   
31. 三个杀人的子类：   
32.     职业杀手类   
33. /**  
34.  * 职业杀手，杀人不见血，非常快。  
35.  * @author zxy  
36.  *  
37.  */  
38. public class ProfessionalKiller extends Killer   
39. {   
40.   
41.     public ProfessionalKiller(Kill killOperation)   
42.     {   
43.         super(killOperation);   
44.         // TODO Auto-generated constructor stub   
45.     }   
46.   
47.     @Override  
48.     public void doKill()   
49.     {   
50.       Kill killOp=getKillOperation();   
51.       System.out.print("我是职业杀手，看我的：");   
52.       killOp.kill();   
53.       System.out.println("快速搞定，闪人,嘻嘻！");   
54.   
55.     }   
56.   
57. }   
58. 普通杀手类   
59. /**  
60.  * 一般杀手，只是杀人费点时间而已  
61.  * @author zxy  
62.  *  
63.  */  
64. public class NormalKiller extends Killer   
65. {   
66.   
67.     public NormalKiller(Kill killOperation)   
68.     {   
69.         super(killOperation);   
70.         // TODO Auto-generated constructor stub   
71.     }   
72.   
73.     @Override  
74.     public void doKill()   
75.     {   
76.         Kill killOp=getKillOperation();   
77.         System.out.print("我是普通杀手，看我的：");   
78.         killOp.kill();   
79.         System.out.println(",总算完成任务，回去向boss报告去！");   
80.   
81.     }   
82.   
83. }   
84. 笨杀手类   
85. /**  
86.  * 笨杀手，杀的慢而且被警察抓住了  
87.  * @author zxy  
88.  *  
89.  */  
90. public class StupidKiller extends Killer   
91. {   
92.   
93.     public StupidKiller(Kill killOperation)   
94.     {   
95.         super(killOperation);   
96.         // TODO Auto-generated constructor stub   
97.     }   
98.   
99.     @Override  
100.     public void doKill()   
101.     {   
102.         Kill killOp=getKillOperation();   
103.         System.out.print("我是一个笨笨的杀手，看我的：");   
104.         killOp.kill();   
105.        System.out.println("怎么老杀不了，完了，警察来了，555!!");   
106.   
107.     }   
108. }   
109. 两种杀人手段：   
110.   枪杀   
111.  /**  
112.  * 枪杀，比较现代的杀人手段  
113.  * @author zxy  
114.  *  
115.  */  
116. public class ShootKill implements Kill   
117. {   
118.    public void kill()   
119.    {   
120.        System.out.print("瞄准...，射击-->>>，");   
121.    }   
122. }   
123. 火杀（就是用火杀人）   
124. /**  
125.  * 纵火烧人，比较残忍的杀人方式  
126.  * @author zxy  
127.  *  
128.  */  
129. public class BurnKill implements Kill   
130. {   
131.   
132.     public void kill()   
133.     {   
134.          System.out.print("点火...，我烧我烧我烧烧烧，");   
135.            
136.     }   
137.   
138. }我们来测试一下杀手的表现：   
139. public class TestKiller   
140. {   
141.     /**  
142.      * @param args  
143.      */  
144.     public static void main(String[] args)   
145.     {   
146.       Kill burnKill=new BurnKill();   
147.       Kill shootKill=new ShootKill();   
148.       Killer professionKiller1=new ProfessionalKiller(burnKill);   
149.       Killer professionKiller2=new ProfessionalKiller(shootKill);   
150.       Killer stupidKiller =new StupidKiller(shootKill);   
151.       System.out.println("下面我们看看杀手们的表演：");   
152.       professionKiller1.doKill();   
153.       stupidKiller.doKill();   
154.       professionKiller2.doKill();   
155.     }   
156.   
157. }   

  看看结果：<o:p></o:p>

下面我们看看杀手们的表演：<o:p></o:p>

我是职业杀手，看我的：点火...，我烧我烧我烧烧烧，快速搞定，闪人,嘻嘻！<o:p></o:p>

我是一个笨笨的杀手，看我的：瞄准...，射击-->>>，怎么老杀不了，完了，警察来了，555!!<o:p></o:p>

我是职业杀手，看我的：瞄准...，射击-->>>，快速搞定，闪人,嘻嘻！<o:p></o:p>

正如预料的一样，杀手们使用不同的手段去表现了他们的杀人技术。<o:p></o:p>

<o:p> </o:p>

可以很清晰的看到在类的设计里面我们将行为抽象出来了，这种设计的好处在于可以很方便的适应行为的扩充时和属性的扩充，比如我们现在出现了一个“投毒的高手”只需要增加一个“投毒”的杀人手段就可以了，反过来，如果将属性和行为绑定，或者单单是把不同杀手（比如“职业杀手”）进行扩充为“投毒高手”,“射击高手”，如此一个增加一种手段的各个级别的杀手将是一间不容易的事。<o:p></o:p>

  这就是“bridge“模式的设计初衷－抽象行为。

第一次写这样的文章，轻拍。<o:p></o:p>