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