（十四）桥接模式详解（都市异能版）

魔都国贸附近，某天夜里十一点半。

那一晚，魔都出奇的没有做只打雷不下雨的勾当，老天似乎是要将魔都淹没一般，倾盆大雨像不要命似的拍打着地面。

漆黑的夜幕中，一道黑影从一个十字路口狂奔而出，而就在此时，一辆红色宝马急速穿过，一瞬间，黑影就犹如被巨力抛飞一般腾空而起，直到几秒钟后，才重重的摔落在车前足足二十多米处。

“吱...兹....”

一声凄厉的刹车声划破了魔都的长空。

之后，一个身材高挑的女子，慌忙的从车中奔跑到黑影落下的地方，或许是由于看到倒下之人满身鲜血的模样，女子吓的不禁发出一声惊叫后退了几步，愣是咬着牙迟迟不敢上前。

或许是由于慌乱之下失了神，女子后退的时候，差点被一个物体绊倒。女子低头一看，竟然是一只拖鞋，不知为何，看到这一幕，一时间女子的心绪稳定了不少。

待得情绪稳定以后，女子这才再次意识到自己撞到人了，而此人到现在还不知死活。于是女子急忙再次跑到黑影身旁，开始试图叫醒这位被自己撞伤的路人，而由于此时一直是大雨倾盆，被撞之人身上的鲜血已经被冲刷干净，女子也渐渐的看清了黑影的面貌。

此人看起来年纪不大，穿着一条大裤衩和一条普通的黑色T恤，光着两个脚丫子，五官倒还算端正，只是满脸的青春痘将其仅有的一点英俊全部淹没，不过从此人光着的脚丫子就可以看出，刚才地上的拖鞋应该就是此人被撞飞的鞋子了。

久久尝试叫醒伤者未果之后，女子无奈之下，只好使出浑身的力气才堪堪拖动此人，等到将受伤之人拖入车中之后，女子其实已经累的满身大汗，只是在这风雨交加的夜晚，看不出来罢了。

XX医院急救室。

“你说什么？死了？”女子瞪大着一双晶莹的眼珠，不可思议的凝视着眼前宣布结果的医生。

此时，在灯光的照耀下，才看清女子的面貌，女子穿着一身白色蕾丝连衣裙，一双眼睛简直像浸在水中的水晶一样澄澈，肤色晶莹如玉，薄薄的唇，色淡如水，清秀的五官里透露出一种说不出的乖巧。而且由于刚才被大雨淋湿，女子的全身已经湿透，仔细看去，隐约可见其包裹在着装之内的嫩肤，更是给原本就美到极点的女子添加了一份诱人的姿色。

“是的，本来接上输氧管后是有微弱的呼吸的，结果过了几秒钟之后就彻底断气了，对不起，我们已经尽力了。”医生叹息一声说道，紧接着，医生继续说道：“这是他临死前让我给你的，请节哀吧”。说着，医生便将手中的一张纸条递给了女子，而快接触到女子玉手的时候，医生忍不住吞了口口水，显然是被女子的美色惊到了。

女子在听完医生的宣判之后，差点晕倒在地，幸好离座位很近，所以才一屁股做到了座位上，不至于摔倒。呆呆的望着正在被缓缓的推往太平间的急救车，女子有点不知所措，她到现在甚至都不知道自己撞死之人姓谁名谁。

想起刚才医生说的话，女子这才意识到手中握着的纸条，打开一看，女子的表情瞬间凝固了，只见纸条上歪歪曲曲的写着几个字：你TM踩着我输氧管了。

XX医院太平间。

“尼玛，二货医生，老子用尽了生前的力量，才勉强写了那么几个字。这蠢货也不打开看看，竟然以为我是临死前写给女友的小情书，也不想想，老子命都快没了， 还写毛毛情书啊。再说，看我这屌丝样，外面那女神能是我女友吗。我真是去年买了个表。” 骂骂咧咧的声音从太平间中传来，这要是被他人听到了，估计当场就要被吓昏过去。

只见一个人影从急救床上缓缓的坐起来，令人惊奇的是，此人竟然生生的穿过了铺在身上的白布，看上去就像是此人不存在一般。坐起的一人，正是被刚才的貌美女子撞死之人，而此人，正是加班到深夜的小左。

“貌似老子转生了啊，就是这身体咋跟个魂儿似的，完全没有实体感啊。难道让我就这样每天飘来飘去的，我擦。”看着自己几乎透明的身体，小左没有时间为自己的死后转生所兴奋，而是紧皱着眉头开始琢磨自己的身体。

“啊哈，我拥有异能了啊，这简直是太TM逆天了。”小左研究了将近三个小时，终于发现了自己的异常。然而在发现自己竟然神奇的拥有了异能之后，小左已然压抑不住内心的兴奋，在太平间里大喊大叫，完全不顾身边沉睡的众人们。

不过兴奋只持续了片刻，小左便眉头紧皱，一脸闷闷不乐的样子，因为他的面前站着八个小左，是的，八个。

小左在研究以后发现，他是拥有异能没错，而且可以转换成屌丝和高富帅的形象，但是让人抓狂的是，他必须先分离出屌丝和高富帅的分身，然后才能由这两个分身，再次分离出带有异能的屌丝和高富帅形象的分身，这些异能分别都有隐身，飞行以及读心术，而且一个分身同时只能有一种能力。所以这样两两组合，最后就出现了八个小左，分别是纯屌丝和高富帅分身，以及拥有一种异能的三个屌丝分身，以及分别拥有一种异能的三个高富帅分身。

不过令人欣喜的是，这八个分身都是真真实实的实体，或者说他们除了有特殊能力之外，其实和现实中的人类是一模一样的，尤其是具有屌丝模样的分身，完全和身前的小左一模一样。不过小左变成高富帅以后的样子，倒是真的很帅，长眉若柳，身如玉树，原本坑坑洼洼的脸庞一时间也光滑嫩白，比之女生也丝毫不差。想必就这个样子，除非是与小左特别熟悉的人，才能仔细的从这分身当中看出一丝似曾相识的感觉。

只是目前这种情况虽说有意外的惊喜，但小左仍然觉得十分糟糕。

原因就是，他要是想使用带有异能的分身，则至少需要创造两次分身，一次无技能的屌丝或者高富帅分身，一次则是在此基础上分离出带有异能的分身。还有更致命的一点，就是如果以后正在使用某一个技能的分身，而恰巧在关键时刻需要使用当前异能之外的两个的话，则需要临时替换掉分身，而替换一个分身，则至少需要两次分身的分离。要知道，分身的产生可是相当耗时的，虽说也不长，但十分八分的，还是要的。

“不知道这种情况，能不能用设计模式解决呢？”哪怕是死后转生，思维方式依旧没有变化。前世身为程序猿的小左，在转生后遇到问题时，第一时间想到的，竟然是设计模式。

说干就干，小左收起八个分身，便控制着自己飘忽的身体开始寻找电脑，因为必须要有电脑，才能激发自己的设计灵感。

寻找的途中，小左也发现，别人竟然完全看不到自己，不过这其实早在小左的意料之中。至于原因，用脚趾头都能想的明白，都已经变成魂魄了，还能看见个毛啊。

由于此时已至深夜，所以医院所剩的工作人员寥寥无几，凭借着可以穿透一切实物的身体，小左很轻易的就找到了一个无人的办公室。不过当小左按下电脑开机键的时候，竟然发现自己的手直接穿过了机箱。

“靠！”愤怒的爆了声粗口，无奈之下，小左只好暂时将自己不带异能的屌丝分身给招了出来，用来帮自己操作电脑。

在经过半个多小时左右的捯饬之后，小左已经在机子上安装好了JDK以及eclipse。于是没有任何犹豫，小左就开始模拟刚才自己的情况。

“刚才的情况来看，我自己的灵魂体以及八个分身，很明显应该是一个继承体系。而我的灵魂体，就是这个继承体系的超级父类。不过由于灵魂体没有实体，所以做成抽象的可能更合适点。不过我可以先来个简单的类图看一下他们的关系。”小左一边自言自语，一边已经开始了在电脑上勾画类图。

“画出类图果然更加清晰一点，这是一个标准的简单的继承体系，下面我就用代码来尝试着写一下吧。”说着，小左便开始在键盘上敲打着代码。

[java] view plaincopyprint?

1. package com.bridge;
2. //抽象灵魂类
3. public abstract class Soul {
4. public void createDoppelganger(){
5. System.out.println("制作分身");
6. }
7. }

package com.bridge;
//抽象灵魂类
public abstract class Soul {

	public void createDoppelganger(){
		System.out.println("制作分身");
	}

}

[java] view plaincopyprint?

1. package com.bridge;
2. //屌丝分身
3. class Loser extends Soul{
4. public Loser(){
5. System.out.println("制造一个无技能的屌丝分身");
6. }
7. public void doAllLikePeople(){
8. System.out.println("分身可以像正常人一样做任何事");
9. }
10. public void show(){
11. System.out.println("展示屌丝形象");
12. }
13. }
14. //高富帅分身
15. class TRH extends Soul {
16. public TRH(){
17. System.out.println("制造一个无技能的高富帅分身");
18. }
19. public void doAllLikePeople(){
20. System.out.println("分身可以像正常人一样做任何事");
21. }
22. public void show(){
23. System.out.println("展示高富帅形象");
24. }
25. }

package com.bridge;
//屌丝分身
class Loser extends Soul{

	public Loser(){
		System.out.println("制造一个无技能的屌丝分身");
	}

	public void doAllLikePeople(){
		System.out.println("分身可以像正常人一样做任何事");
	}

	public void show(){
		System.out.println("展示屌丝形象");
	}

}
//高富帅分身
class TRH extends Soul {

	public TRH(){
		System.out.println("制造一个无技能的高富帅分身");
	}

	public void doAllLikePeople(){
		System.out.println("分身可以像正常人一样做任何事");
	}

	public void show(){
		System.out.println("展示高富帅形象");
	}

}

[java] view plaincopyprint?

1. package com.bridge;
2. //带有隐身技能的屌丝分身
3. class InvisibleLoser extends Loser{
4. public InvisibleLoser(){
5. System.out.println("制造一个带隐身技能的屌丝分身");
6. }
7. public void releaseSkills(){
8. System.out.println("屌丝分身释放隐身技能");
9. }
10. }
11. //带有飞行技能的屌丝分身
12. class VolantLoser extends Loser{
13. public VolantLoser(){
14. System.out.println("制造一个带飞行技能的屌丝分身");
15. }
16. public void releaseSkills(){
17. System.out.println("屌丝分身释放飞行技能");
18. }
19. }
20. //带有读心术技能的屌丝分身
21. class ReadMindLoser extends Loser{
22. public ReadMindLoser(){
23. System.out.println("制造一个带读心术技能的屌丝分身");
24. }
25. public void releaseSkills(){
26. System.out.println("屌丝分身释放读心术技能");
27. }
28. }
29. //带有隐身技能的高富帅分身
30. class InvisibleTRH extends TRH{
31. public InvisibleTRH(){
32. System.out.println("制造一个带隐身技能的高富帅分身");
33. }
34. public void releaseSkills(){
35. System.out.println("高富帅分身释放隐身技能");
36. }
37. }
38. //带有飞行技能的高富帅分身
39. class VolantTRH extends TRH{
40. public VolantTRH(){
41. System.out.println("制造一个带飞行技能的高富帅分身");
42. }
43. public void releaseSkills(){
44. System.out.println("高富帅分身释放飞行技能");
45. }
46. }
47. //带有读心术技能的高富帅分身
48. class ReadMindTRH extends TRH{
49. public ReadMindTRH(){
50. System.out.println("制造一个带读心术技能的高富帅分身");
51. }
52. public void releaseSkills(){
53. System.out.println("高富帅分身释放读心术技能");
54. }
55. }

package com.bridge;
//带有隐身技能的屌丝分身
class InvisibleLoser extends Loser{

	public InvisibleLoser(){
		System.out.println("制造一个带隐身技能的屌丝分身");
	}

	public void releaseSkills(){
		System.out.println("屌丝分身释放隐身技能");
	}
}
//带有飞行技能的屌丝分身
class VolantLoser extends Loser{

	public VolantLoser(){
		System.out.println("制造一个带飞行技能的屌丝分身");
	}

	public void releaseSkills(){
		System.out.println("屌丝分身释放飞行技能");
	}
}
//带有读心术技能的屌丝分身
class ReadMindLoser extends Loser{

	public ReadMindLoser(){
		System.out.println("制造一个带读心术技能的屌丝分身");
	}

	public void releaseSkills(){
		System.out.println("屌丝分身释放读心术技能");
	}
}
//带有隐身技能的高富帅分身
class InvisibleTRH extends TRH{

	public InvisibleTRH(){
		System.out.println("制造一个带隐身技能的高富帅分身");
	}

	public void releaseSkills(){
		System.out.println("高富帅分身释放隐身技能");
	}
}
//带有飞行技能的高富帅分身
class VolantTRH extends TRH{

	public VolantTRH(){
		System.out.println("制造一个带飞行技能的高富帅分身");
	}

	public void releaseSkills(){
		System.out.println("高富帅分身释放飞行技能");
	}
}
//带有读心术技能的高富帅分身
class ReadMindTRH extends TRH{

	public ReadMindTRH(){
		System.out.println("制造一个带读心术技能的高富帅分身");
	}

	public void releaseSkills(){
		System.out.println("高富帅分身释放读心术技能");
	}
}

“恩，我的灵魂体以及这几个分身的关系倒是挺简单粗暴，就是继承，那么现在这种情况下我在使用的时候，应该就像下面这样了。”

[java] view plaincopyprint?

1. package com.bridge;
2. public class Use {
3. public static void main(String[] args) {
4. InvisibleLoser invisibleLoser = new InvisibleLoser();
5. invisibleLoser.releaseSkills();
6. System.out.println("------------------------------------");
7. ReadMindTRH readMindTRH = new ReadMindTRH();
8. readMindTRH.releaseSkills();
9. System.out.println("------------------------------------");
10. InvisibleTRH invisibleTRH = new InvisibleTRH();
11. invisibleTRH.releaseSkills();
12. }
13. }

package com.bridge;

public class Use {

	public static void main(String[] args) {
		InvisibleLoser invisibleLoser = new InvisibleLoser();
		invisibleLoser.releaseSkills();
		System.out.println("------------------------------------");
		ReadMindTRH readMindTRH = new ReadMindTRH();
		readMindTRH.releaseSkills();
		System.out.println("------------------------------------");
		InvisibleTRH invisibleTRH = new InvisibleTRH();
		invisibleTRH.releaseSkills();
	}

}

看着输出的结果，小左摇了摇头，自言自语道：“果然与我刚才的分析一模一样，每次切换技能的时候，都至少需要制造两次分身，才可以切换成功，这样的话，切换技能非常不方便。而且万一以后我又领悟一个技能，又或者增加了一种外貌，那么分身的数量会急剧增加。”

“那么到底什么设计模式可以解决这个问题呢？”小左喃喃的说道。

在说话的同时，小左已经开始在度娘上搜索合适的设计模式，试图解决自己的分身问题。

“有了，啊哈。桥接模式正是解决这个问题的利器啊。”小左犹如发现了新大陆一般兴奋的叫道，而双眼则死死的盯着桥接模式的定义。

定义：在软件系统中，某些类型由于自身的逻辑，它具有两个或多个维度的变化，那么如何应对这种“多维度的变化”？如何利用面向对象的技术来使得该类型能够轻松的沿着多个方向进行变化，而又不引入额外的复杂度？这就要使用Bridge模式。而具体使用的方式，则是将抽象部分与他们的实现部分分离，使得它们都可以独立的变化。

“桥接模式中说到了某些类型，会有两个或多个维度的变化，这里指的不正是我的分身吗。我的分身既可以按外貌分类，即屌丝和高富帅，又可以按技能分类，即隐身、飞行和读心术。不过这使用方式倒是说的有些模糊。”小左看着桥接模式的定义，喃喃的说道。

“还是看下类图吧，说不定能找到一些端倪。”说着，小左就在度娘上打开了桥接模式的类图。

“从类图上看，抽象部分的具体行为交给了实现部分，而就我目前的情况来说，我的不同实现有两种，一种是外貌，一种是技能。这么说的话，抽象部分和实现部分，通常意义下，应该指的是继承体系中，接口相同而实现也相同的部分则为抽象部分，而接口相同但是实现不同的部分则为实现部分。”

“这样的话，按照我目前的情况，制作分身以及像正常人一样做任何事的方法则是抽象部分，而形象的展示和技能的释放则是实现部分了。下面我就尝试着来分离一下吧，哈哈！”有了解决方案，小左不禁心情大好，慌里慌张的就开始尝试着分离抽象和实现部分。

“首先，我要将实现部分给写出来，这里有两个维度，一个是技能，一个是外貌。”

[java] view plaincopyprint?

1. package com.bridge;
2. //技能接口
3. public interface Skills {
4. public void releaseSkills();
5. }
6. //隐身技能
7. class Invisible implements Skills{
8. public void releaseSkills(){
9. System.out.println("释放隐身技能");
10. }
11. }
12. //飞行技能
13. class Volant implements Skills{
14. public void releaseSkills(){
15. System.out.println("释放飞行技能");
16. }
17. }
18. //读心术技能
19. class ReadMind implements Skills{
20. public void releaseSkills(){
21. System.out.println("释放读心术技能");
22. }
23. }

package com.bridge;

//技能接口
public interface Skills {

	public void releaseSkills();

}

//隐身技能
class Invisible implements Skills{

	public void releaseSkills(){
		System.out.println("释放隐身技能");
	}
}
//飞行技能
class Volant implements Skills{

	public void releaseSkills(){
		System.out.println("释放飞行技能");
	}
}
//读心术技能
class ReadMind implements Skills{

	public void releaseSkills(){
		System.out.println("释放读心术技能");
	}
}

[java] view plaincopyprint?

1. package com.bridge;
2. //外貌接口
3. public interface Appearance {
4. public void show();
5. }
6. //屌丝外形
7. class Loser implements Appearance{
8. public void show() {
9. System.out.println("展示屌丝形象");
10. }
11. }
12. //高富帅外形
13. class TRH implements Appearance{
14. public void show() {
15. System.out.println("展示高富帅形象");
16. }
17. }

package com.bridge;
//外貌接口
public interface Appearance {

	public void show();

}
//屌丝外形
class Loser implements Appearance{

	public void show() {
		System.out.println("展示屌丝形象");
	}

}
//高富帅外形
class TRH implements Appearance{

	public void show() {
		System.out.println("展示高富帅形象");
	}

}

“这便是两个实现化的部分了，现在我已经将它分离出来，剩下的就是要将他们加入到灵魂基类中了。”

[java] view plaincopyprint?

1. package com.bridge;
2. //抽象灵魂类
3. public abstract class Soul {
4. protected Appearance appearance;//外貌
5. protected Skills skills;//技能
6. //具体的实现交给实现部分处理
7. public void show(){
8. appearance.show();
9. }
10. //具体的实现交给实现部分处理
11. public void releaseSkills(){
12. skills.releaseSkills();
13. }
14. public void createDoppelganger(){
15. System.out.println("制作分身");
16. }
17. //抽象的方法，留给分身实现
18. public abstract void doAllLikePeople();
19. public Soul() {
20. super();
21. }
22. public Soul(Skills skills) {
23. super();
24. this.skills = skills;
25. }
26. public Soul(Appearance appearance) {
27. super();
28. this.appearance = appearance;
29. }
30. public Soul(Appearance appearance, Skills skills) {
31. super();
32. this.appearance = appearance;
33. this.skills = skills;
34. }
35. public Appearance getAppearance() {
36. return appearance;
37. }
38. public void setAppearance(Appearance appearance) {
39. this.appearance = appearance;
40. }
41. public Skills getSkills() {
42. return skills;
43. }
44. public void setSkills(Skills skills) {
45. this.skills = skills;
46. }
47. }

package com.bridge;
//抽象灵魂类
public abstract class Soul {

	protected Appearance appearance;//外貌

	protected Skills skills;//技能

	//具体的实现交给实现部分处理
	public void show(){
		appearance.show();
	}
	//具体的实现交给实现部分处理
	public void releaseSkills(){
		skills.releaseSkills();
	}

	public void createDoppelganger(){
		System.out.println("制作分身");
	}
	//抽象的方法，留给分身实现
	public abstract void doAllLikePeople();

	public Soul() {
		super();
	}

	public Soul(Skills skills) {
		super();
		this.skills = skills;
	}

	public Soul(Appearance appearance) {
		super();
		this.appearance = appearance;
	}

	public Soul(Appearance appearance, Skills skills) {
		super();
		this.appearance = appearance;
		this.skills = skills;
	}

	public Appearance getAppearance() {
		return appearance;
	}

	public void setAppearance(Appearance appearance) {
		this.appearance = appearance;
	}

	public Skills getSkills() {
		return skills;
	}

	public void setSkills(Skills skills) {
		this.skills = skills;
	}

}

“这下已经基本搞定了，最后一步则是我要修正一下灵魂类，因为灵魂类只是定义了抽象化的角色，它是需要分身类来修正以后，才可以拥有真正的像人类一样活动的能力。”

[java] view plaincopyprint?

1. package com.bridge;
2. //分身类
3. public class Doppelganger extends Soul{
4. public Doppelganger(){
5. System.out.println("制作一个暂无外貌和技能的分身");
6. }
7. public void doAllLikePeople(){
8. System.out.println("分身可以像正常人一样做任何事");
9. }
10. }

package com.bridge;

//分身类
public class Doppelganger extends Soul{

	public Doppelganger(){
		System.out.println("制作一个暂无外貌和技能的分身");
	}

	public void doAllLikePeople(){
		System.out.println("分身可以像正常人一样做任何事");
	}

}

“OK了，这下我来看一下现在要使用的话要怎么使用吧。”到了此时，小左明显已经有点迫不及待了。

[java] view plaincopyprint?

1. package com.bridge;
2. public class Use {
3. public static void main(String[] args) {
4. Soul soul = new Doppelganger();
5. soul.setAppearance(new TRH());//设置分身外貌为高富帅
6. soul.setSkills(new Invisible());//设置隐身技能
7. soul.doAllLikePeople();
8. System.out.println("----------------------------");
9. soul.show();
10. soul.releaseSkills();
11. System.out.println("----------------------------");
12. //切换技能
13. soul.setSkills(new ReadMind());
14. soul.releaseSkills();
15. System.out.println("----------------------------");
16. //切换外貌
17. soul.setAppearance(new Loser());
18. soul.show();
19. System.out.println("----------------------------");
20. //切换技能
21. soul.setSkills(new Volant());
22. soul.releaseSkills();
23. }
24. }

package com.bridge;

public class Use {

	public static void main(String[] args) {
		Soul soul = new Doppelganger();
		soul.setAppearance(new TRH());//设置分身外貌为高富帅
		soul.setSkills(new Invisible());//设置隐身技能
		soul.doAllLikePeople();
		System.out.println("----------------------------");
		soul.show();
		soul.releaseSkills();
		System.out.println("----------------------------");
		//切换技能
		soul.setSkills(new ReadMind());
		soul.releaseSkills();
		System.out.println("----------------------------");
		//切换外貌
		soul.setAppearance(new Loser());
		soul.show();
		System.out.println("----------------------------");
		//切换技能
		soul.setSkills(new Volant());
		soul.releaseSkills();
	}

}

                “不错不错。这下我可以随意切换外貌和技能了，而且要是以后万一我领悟什么新的技能，按照以前的方式的话，我至少需要添加两个子类，而要是拥有新的外貌的话，则至少需要添加四个子类，而现在的话，不管是那种情况，我都只需要添加一个子类，就可以随意切换。”

“不过说起来的话，这好处应该不止这些，我还是专门总结和对比一下吧，省得以后使用的时候遇见什么问题，自己搞不清楚。”

转生之后，小左还是改不掉前世的习惯，在每次使用设计模式解决完问题之后，都喜欢总结一番。而在世之时，小左的这个习惯，则全是为了在小甜甜面前得瑟所养成的。

“先画个类图来看一下现在的关系。”说着，小左便开始画起类图来了。

“这图当中，红色的则是抽象部分，黄色的则是实现部分，而两者之间被两条线连接，看起来就像是一座桥一样，怪不得这个设计模式叫桥接模式呢。”看着自己画出来的类图，小左忽然觉得，桥接模式这个名字，起的实在是妙。

“下面，我就得总结一下前后的好处和坏处了。”

首先，得先总结一下以前的坏处都是哪些。

第一，分身太多，不容易控制。

第二，不同技能和不同外貌之间，切换起来非常不灵活。

第三，要是想添加技能或者外貌的分类的话，要产生的分身非常多。

要是从专业点的角度来分析的话，则应该是下面这几点了。

第一，子类太多。

                第二，由于客户端与具体子类的耦合度很高，导致在子类间切换非常繁琐。

                第三，如果以后需要扩展子类功能的话，则子类的数目会随着维度以及每一个维度中子类的个数的增加呈几何倍数增长。

那么现在的好处则是一下几点了。

第一，分身的数目减少了，而且伴随着技能和外貌的种类的增加，这种减少会越来越明显。

第二，在不同技能和不同外貌之间的切换将会非常灵活。

第三，如果以后技能和外貌的种类增加了，又或者分身又可以按其它的属性分类了，那么这种添加会非常容易。

如果把好处说的专业一点的话，则是下面这样。

第一，子类的数目减少了。

                第二，实现部分的切换非常容易，主要表现在抽象部分和实现部分的耦合度很低，因为使用聚合取代了继承。

                第三，扩展的时候很简单，可以更好的容纳变化，不论是维度的增加还是每一个维度中子类的个数的增加，都会变得非常简单。

疯狂的总结了一番，小左便开始按照桥接模式的设计，尝试着改变对外貌和技能的控制。

果然，在尝试了数十次之后，一个普通的分身终于被小左给分离了出来，而小左的灵魂中则保存着屌丝和高富帅的外貌以及三种异能。

伴随着小左的意念变动，这个普通的分身则会产生响应的变化。忽而是屌丝模样，忽而又变成了高富帅的样子，忽而隐形不见，忽而飞出窗外，又迅速的飞回原地，实在是让小左玩的不亦乐乎。

一年后，魔都某天桥。

“天灵灵，地灵灵，看相算命我最行，上知天文，下知地理，中间明白事理，而且通晓人理，想算命的请找小左先生算命啦。”一个身材高大，长相英俊的小伙子，卖着力气的叫喊着。

此人，正是开启了读心术的小左，而之所以变成现在这样，则是因为隐身和飞行虽然很酷，但却偏偏不能拿来赚钱。无奈之下，小左只好委曲求全，先暂时当起了算命先生。说是这么说，但实际上小左现在每天赚的钱，是以前当程序猿时的数倍不止。

此时的他，更是华丽丽的披了一身高富帅的形象，为的就是多吸引几个女顾客。不过这一招还真的相当凑效，已经有不少穿着暴露，性感火辣的女顾客来光顾了小左的生意。

这不，说着说着，一位穿着火红短裙的性感辣妹已然来到了小左摊前，“帅哥先生，麻烦你帮我看下，我的命中有没有你呢？”

“我要收摊了，不好意思。”感受到对方明显的勾引，小左并没有任何触动。而此时刚好也正值傍晚，于是小左只是淡漠的摆了摆手，就打算收摊回家。

这一年中，前世做了二十多年单身屌丝的小左，在拥有了飞行和隐身的异能之后，自然是好好的享受了一番人间乐趣，故而现在纵然是面对这种程度的勾引，小左依然可以做到无动于衷。而之所以变成这样，不光是因为这一年之中，小左对女人的定力大大增加，最重要的是，面前的女人一看就是只调戏不掏钱的主。

然而就在小左准备转身回家的时候，却是被身后一道轻柔的声音给叫住了。

“您好，可以给我算一下吗？”

听到有人叫，小左就打算回头婉拒之后直接回家，然而就在小左转过身来，看到面前女子的时候，小左却犹如被雷击一般，楞在那里一动不动。片刻之后，才颤抖的说道：“你...你就是...”