杀人中的技术

  

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

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

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

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

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

1．  显然“杀手”是基类，三类杀手是子类

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

我是这么设计的：

杀手类

/**

  * 杀手的封装类

  * @author zxy

  *

  */

public abstract class Killer

{

    private Kill killOperation ;

    public Killer(Kill killOperation )

    {

       this . killOperation =killOperation;

    }

    public abstract void doKill();

    public Kill getKillOperation()

    {

       return killOperation ;

    }

 

杀人

/**

  * 杀人的动作，抽象为一个接口

  * @author zxy

  *

  */

public interface Kill

{

  public void kill();

}

}

三个杀人的子类：

    职业杀手类

/**

  * 职业杀手，杀人不见血，非常快。

  * @author zxy

  *

  */

public class ProfessionalKiller extends Killer

{

 

    public ProfessionalKiller(Kill killOperation)

    {

       super (killOperation);

       // TODO Auto-generated constructor stub

    }

 

    @Override

    public void doKill()

    {

     Kill killOp=getKillOperation();

     System. out .print( " 我是职业杀手，看我的： " );

     killOp.kill();

     System. out .println( " 快速搞定，闪人 , 嘻嘻！ " );

 

    }

 

}

普通杀手类

/**

  * 一般杀手，只是杀人费点时间而已

  * @author zxy

  *

  */

public class NormalKiller extends Killer

{

 

    public NormalKiller(Kill killOperation)

    {

       super (killOperation);

       // TODO Auto-generated constructor stub

    }

 

    @Override

    public void doKill()

    {

       Kill killOp=getKillOperation();

       System. out .print( " 我是普通杀手，看我的： " );

       killOp.kill();

        System. out .println( ", 总算完成任务，回去向 boss 报告去！ " );

 

    }

 

}

笨杀手类

/**

  * 笨杀手，杀的慢而且被警察抓住了

  * @author zxy

  *

  */

public class StupidKiller extends Killer

{

 

    public StupidKiller(Kill killOperation)

    {

       super (killOperation);

       // TODO Auto-generated constructor stub

    }

 

    @Override

    public void doKill()

    {

       Kill killOp=getKillOperation();

       System. out .print( " 我是一个笨笨的杀手，看我的： " );

        killOp.kill();

       System. out .println( " 怎么老杀不了，完了，警察来了， 555!!" );

 

    }

}

两种杀人手段：

  枪杀

  /**

  * 枪杀，比较现代的杀人手段

  * @author zxy

  *

  */

public class ShootKill implements Kill

{

   public void kill()

   {

       System. out .print( " 瞄准 ... ，射击 -->>> ， " );

   }

}

火杀 （就是用火杀人）

/**

  * 纵火烧人，比较残忍的杀人方式

  * @author zxy

  *

  */

public class BurnKill implements Kill

{

 

    public void kill()

    {

        System. out .print( " 点火 ... ，我烧我烧我烧烧烧， " );

      

    }

 

} 我们来测试一下杀手的表现：

public class TestKiller

{

    /**

      * @param args

      */

    public static void main(String[] args)

    {

     Kill burnKill= new BurnKill();

     Kill shootKill= new ShootKill();

     Killer professionKiller1= new ProfessionalKiller(burnKill);

     Killer professionKiller2= new ProfessionalKiller(shootKill);

     Killer stupidKiller = new StupidKiller(shootKill);

     System. out .println( " 下面我们看看杀手们的表演： " );

     professionKiller1.doKill();

     stupidKiller.doKill();

     professionKiller2.doKill();

    }

 

}

看看结果：

下面我们看看杀手们的表演：

我是职业杀手，看我的：点火 ... ，我烧我烧我烧烧烧，快速搞定，闪人 , 嘻嘻！

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

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

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

 

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

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