论坛首页 入门技术论坛

杀人中的技术

浏览 3033 次
该帖已经被评为新手帖
作者 正文
   发表时间:2006-11-23  
 

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

 

   发表时间:2006-11-23  
无聊!
0 请登录后投票
   发表时间:2006-11-23  
应该是从blog过来的吧   活用code标签啊  这样看起来不方便的
0 请登录后投票
论坛首页 入门技术版

跳转论坛:
Global site tag (gtag.js) - Google Analytics