- 浏览: 264339 次
- 性别:
- 来自: 北京
文章分类
最新评论
-
cuiqi4016:
正在做json转换的功能,帮大忙了,感谢博主分享
java 通过反射获取泛型的类型 -
cxshun:
写得很好,感谢博主的分享
java 通过反射获取泛型的类型 -
joy3229233:
[url][/url][flash=200,200][/fla ...
(转)flex checkbox 选中 -
linkagebest:
盗版可耻。。。。。
(转)flex checkbox 选中 -
shuai0420:
...
flex数据绑定
学习设计模式也有一段时间了,今天就把我整理的一篇课程和大家分享,有不妥之处欢迎指出.
生活中的一个例子:
就拿汽车在路上行驶的来说。即有小汽车又有公共汽车,它们都不但能在市区中的公路上行驶,也能在高速公路上行驶。这你会发现,对于交通工具(汽车)有不同的类型,然而它们所行驶的环境(路)也在变化,在软件系统中就要适应两个方面的变化?怎样实现才能应对这种变化呢?
概述:
在软件系统中,某些类型由于自身的逻辑,它具有两个或多个维度的变化,那么如何应对这种“多维度的变化”?如何利用面向对象的技术来使得该类型能够轻松的沿着多个方向进行变化,而又不引入额外的复杂度?这就要使用Bridge模式。
意图:
将抽象部分与实现部分分离,使它们都可以独立的变化。
——《设计模式》GOF
代码实现:
1namespace CarRunOnRoad
2{
3 //路的基类;
4 public class Road
5 {
6 public virtual void Run()
7 {
8 Console.WriteLine("在路上");
9 }
10 }
11 //高速公路;
12 public class SpeedWay : Road
13 {
14 public override void Run()
15 {
16 Console.WriteLine("高速公路");
17 }
18 }
19 //市区街道;
20 public class Street : Road
21 {
22 public override void Run()
23 {
24 Console.WriteLine("市区街道");
25 }
26 }
27 //小汽车在高速公路上行驶;
28 public class CarOnSpeedWay : SpeedWay
29 {
30 public override void Run()
31 {
32 Console.WriteLine("小汽车在高速公路上行驶");
33 }
34 }
35 //公共汽车在高速公路上行驶;
36 public class BusOnSpeedWay : SpeedWay
37 {
38 public override void Run()
39 {
40 Console.WriteLine("公共汽车在高速公路上行驶");
41 }
42 }
43 //小汽车在市区街道上行驶;
44 public class CarOnStreet : Street
45 {
46 public override void Run()
47 {
48 Console.WriteLine("汽车在街道上行驶");
49 }
50 }
51 //公共汽车在市区街道上行驶;
52 public class BusOnStreet : Street
53 {
54 public override void Run()
55 {
56 Console.WriteLine("公共汽车在街道上行驶");
57 }
58 }
59
60}
客户端调用:
1static void Main(string[] args)
2 {
3 //小汽车在高速公路上行驶
4 CarOnSpeedWay Car = new CarOnSpeedWay();
5 Car.Run();
6
7 Console.WriteLine("===========================");
8
9 //公共汽车在街道上行驶
10 BusOnStreet Bus = new BusOnStreet();
11 Bus.Run();
12
13 Console.Read();
14 }
缺点:
但是我们说这样的设计是脆弱的,仔细分析就可以发现,它还是存在很多问题,首先它在遵循开放-封闭原则的同时,违背了类的单一职责原则,即一个类只有一个引起它变化的原因,而这里引起变化的原因却有两个,即路类型的变化和汽车类型的变化;其次是重复代码会很多,不同的汽车在不同的路上行驶也会有一部分的代码是相同的;再次是类的结构过于复杂,继承关系太多,难于维护,最后最致命的一点是扩展性太差。如果变化沿着汽车的类型和不同的道路两个方向变化,我们会看到这个类的结构会迅速的变庞大。
应用设计模式
桥接模式(Bridge)来做;
代码实现:
1namespace CarRunOnRoad_Bridge_
2{
3
4 //抽象路
5 public abstract class AbstractRoad
6 {
7 protected AbstractCar car;
8 public AbstractCar Car
9 {
10 set
11 {
12 car = value;
13 }
14 }
15
16 public abstract void Run();
17 }
18
19 //高速公路
20 public class SpeedWay : AbstractRoad
21 {
22 public override void Run()
23 {
24 car.Run();
25 Console.WriteLine("高速公路上行驶");
26 }
27 }
28
29 //市区街道
30 public class Street : AbstractRoad
31 {
32 public override void Run()
33 {
34 car.Run();
35 Console.WriteLine("市区街道上行驶");
36 }
37 }
38}
1namespace CarRunOnRoad_Bridge_
2{
3 //抽象汽车
4 public abstract class AbstractCar
5 {
6 public abstract void Run();
7 }
8
9 //小汽车;
10 public class Car : AbstractCar
11 {
12 public override void Run()
13 {
14 Console.Write("小汽车在");
15 }
16 }
17
18 //公共汽车
19 public class Bus : AbstractCar
20 {
21 public override void Run()
22 {
23 Console.Write("公共汽车在");
24 }
25 }
26}
客户端调用:
1 static void Main(string[] args)
2 {
3 //小汽车在高速公路上行驶;
4 AbstractRoad Road1 = new SpeedWay();
5 Road1.Car = new Car();
6 Road1.Run();
7 Console.WriteLine("=========================");
8
9 //公共汽车在高速公路上行驶;
10 AbstractRoad Road2 = new SpeedWay();
11 Road2.Car = new Bus();
12 Road2.Run();
13
14
15
16 Console.Read();
17 }
可以看到,通过对象组合的方式,Bridge 模式把两个角色之间的继承关系改为了耦合的关系,从而使这两者可以从容自若的各自独立的变化,这也是Bridge模式的本意。
这样增加了客户程序与路与汽车的耦合。其实这样的担心是没有必要的,因为这种耦合性是由于对象的创建所带来的,完全可以用创建型模式去解决。在应用时结合创建型设计模式来处理具体的问题。
应用设计模式:
桥接模式(Bridge)来做(多维度变化);
结合上面的例子,增加一个维度"人",不同的人开着不同的汽车在不同的路上行驶(三个维度);
结合上面增加一个类"人",并重新调用.
代码实现:
1namespace CarRunOnRoad_Bridge_
2{
3 abstract class people
4 {
5 AbstractRoad road;
6 public AbstractRoad Road
7 {
8 get
9 {
10 return road;
11 }
12 set
13 {
14 road = value;
15 }
16 }
17 public abstract void Run();
18
19 }
20 class Man : people
21 {
22 public override void Run()
23 {
24 Console.Write("男人开着");
25 Road.Run();
26 }
27 }
28
29 class WoMan : people
30 {
31 public override void Run()
32 {
33 Console.Write("女人开着");
34 Road.Run();
35 }
36 }
37}
客户端调用:
1 static void Main(string[] args)
2 {
3
4 //男人开着公共汽车在高速公路上行驶;
5 Console.WriteLine("=========================");
6
7 AbstractRoad Road3 = new SpeedWay();
8 Road3.Car = new Bus();
9
10 people p = new Man();
11 p.Road = Road3;
12 p.Run();
13
14 Console.Read();
15 }
效果及实现要点:
1.Bridge模式使用“对象间的组合关系”解耦了抽象和实现之间固有的绑定关系,使得抽象和实现可以沿着各自的维度来变化。
2.所谓抽象和实现沿着各自维度的变化,即“子类化”它们,得到各个子类之后,便可以任意它们,从而获得不同路上的不同汽车。
3.Bridge模式有时候类似于多继承方案,但是多继承方案往往违背了类的单一职责原则(即一个类只有一个变化的原因),复用性比较差。Bridge模式是比多继承方案更好的解决方法。
4.Bridge模式的应用一般在“两个非常强的变化维度”,有时候即使有两个变化的维度,但是某个方向的变化维度并不剧烈——换言之两个变化不会导致纵横交错的结果,并不一定要使用Bridge模式。
适用性:
在以下的情况下应当使用桥梁模式:
1.如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性,避免在两个层次之间建立静态的联系。
2.设计要求实现化角色的任何改变不应当影响客户端,或者说实现化角色的改变对客户端是完全透明的。
3.一个构件有多于一个的抽象化角色和实现化角色,系统需要它们之间进行动态耦合。
4.虽然在系统中使用继承是没有问题的,但是由于抽象化角色和具体化角色需要独立变化,设计要求需要独立管理这两者。
总结:
Bridge模式是一个非常有用的模式,也非常复杂,它很好的符合了开放-封闭原则和优先使用对象,而不是继承这两个面向对象原则。
桥接模式与装饰的区别:
装饰模式:
这两个模式在一定程度上都是为了减少子类的数目,避免出现复杂的继承关系。但是它们解决的方法却各有不同,装饰模式把子类中比基类中多出来的部分放到单独的类里面,以适应新功能增加的需要,当我们把描述新功能的类封装到基类的对象里面时,就得到了所需要的子类对象,这些描述新功能的类通过组合可以实现很多的功能组合 .
桥接模式:
桥接模式则把原来的基类的实现化细节抽象出来,在构造到一个实现化的结构中,然后再把原来的基类改造成一个抽象化的等级结构,这样就可以实现系统在多个维度上的独立变化 。
生活中的一个例子:
就拿汽车在路上行驶的来说。即有小汽车又有公共汽车,它们都不但能在市区中的公路上行驶,也能在高速公路上行驶。这你会发现,对于交通工具(汽车)有不同的类型,然而它们所行驶的环境(路)也在变化,在软件系统中就要适应两个方面的变化?怎样实现才能应对这种变化呢?
概述:
在软件系统中,某些类型由于自身的逻辑,它具有两个或多个维度的变化,那么如何应对这种“多维度的变化”?如何利用面向对象的技术来使得该类型能够轻松的沿着多个方向进行变化,而又不引入额外的复杂度?这就要使用Bridge模式。
意图:
将抽象部分与实现部分分离,使它们都可以独立的变化。
——《设计模式》GOF
代码实现:
1namespace CarRunOnRoad
2{
3 //路的基类;
4 public class Road
5 {
6 public virtual void Run()
7 {
8 Console.WriteLine("在路上");
9 }
10 }
11 //高速公路;
12 public class SpeedWay : Road
13 {
14 public override void Run()
15 {
16 Console.WriteLine("高速公路");
17 }
18 }
19 //市区街道;
20 public class Street : Road
21 {
22 public override void Run()
23 {
24 Console.WriteLine("市区街道");
25 }
26 }
27 //小汽车在高速公路上行驶;
28 public class CarOnSpeedWay : SpeedWay
29 {
30 public override void Run()
31 {
32 Console.WriteLine("小汽车在高速公路上行驶");
33 }
34 }
35 //公共汽车在高速公路上行驶;
36 public class BusOnSpeedWay : SpeedWay
37 {
38 public override void Run()
39 {
40 Console.WriteLine("公共汽车在高速公路上行驶");
41 }
42 }
43 //小汽车在市区街道上行驶;
44 public class CarOnStreet : Street
45 {
46 public override void Run()
47 {
48 Console.WriteLine("汽车在街道上行驶");
49 }
50 }
51 //公共汽车在市区街道上行驶;
52 public class BusOnStreet : Street
53 {
54 public override void Run()
55 {
56 Console.WriteLine("公共汽车在街道上行驶");
57 }
58 }
59
60}
客户端调用:
1static void Main(string[] args)
2 {
3 //小汽车在高速公路上行驶
4 CarOnSpeedWay Car = new CarOnSpeedWay();
5 Car.Run();
6
7 Console.WriteLine("===========================");
8
9 //公共汽车在街道上行驶
10 BusOnStreet Bus = new BusOnStreet();
11 Bus.Run();
12
13 Console.Read();
14 }
缺点:
但是我们说这样的设计是脆弱的,仔细分析就可以发现,它还是存在很多问题,首先它在遵循开放-封闭原则的同时,违背了类的单一职责原则,即一个类只有一个引起它变化的原因,而这里引起变化的原因却有两个,即路类型的变化和汽车类型的变化;其次是重复代码会很多,不同的汽车在不同的路上行驶也会有一部分的代码是相同的;再次是类的结构过于复杂,继承关系太多,难于维护,最后最致命的一点是扩展性太差。如果变化沿着汽车的类型和不同的道路两个方向变化,我们会看到这个类的结构会迅速的变庞大。
应用设计模式
桥接模式(Bridge)来做;
代码实现:
1namespace CarRunOnRoad_Bridge_
2{
3
4 //抽象路
5 public abstract class AbstractRoad
6 {
7 protected AbstractCar car;
8 public AbstractCar Car
9 {
10 set
11 {
12 car = value;
13 }
14 }
15
16 public abstract void Run();
17 }
18
19 //高速公路
20 public class SpeedWay : AbstractRoad
21 {
22 public override void Run()
23 {
24 car.Run();
25 Console.WriteLine("高速公路上行驶");
26 }
27 }
28
29 //市区街道
30 public class Street : AbstractRoad
31 {
32 public override void Run()
33 {
34 car.Run();
35 Console.WriteLine("市区街道上行驶");
36 }
37 }
38}
1namespace CarRunOnRoad_Bridge_
2{
3 //抽象汽车
4 public abstract class AbstractCar
5 {
6 public abstract void Run();
7 }
8
9 //小汽车;
10 public class Car : AbstractCar
11 {
12 public override void Run()
13 {
14 Console.Write("小汽车在");
15 }
16 }
17
18 //公共汽车
19 public class Bus : AbstractCar
20 {
21 public override void Run()
22 {
23 Console.Write("公共汽车在");
24 }
25 }
26}
客户端调用:
1 static void Main(string[] args)
2 {
3 //小汽车在高速公路上行驶;
4 AbstractRoad Road1 = new SpeedWay();
5 Road1.Car = new Car();
6 Road1.Run();
7 Console.WriteLine("=========================");
8
9 //公共汽车在高速公路上行驶;
10 AbstractRoad Road2 = new SpeedWay();
11 Road2.Car = new Bus();
12 Road2.Run();
13
14
15
16 Console.Read();
17 }
可以看到,通过对象组合的方式,Bridge 模式把两个角色之间的继承关系改为了耦合的关系,从而使这两者可以从容自若的各自独立的变化,这也是Bridge模式的本意。
这样增加了客户程序与路与汽车的耦合。其实这样的担心是没有必要的,因为这种耦合性是由于对象的创建所带来的,完全可以用创建型模式去解决。在应用时结合创建型设计模式来处理具体的问题。
应用设计模式:
桥接模式(Bridge)来做(多维度变化);
结合上面的例子,增加一个维度"人",不同的人开着不同的汽车在不同的路上行驶(三个维度);
结合上面增加一个类"人",并重新调用.
代码实现:
1namespace CarRunOnRoad_Bridge_
2{
3 abstract class people
4 {
5 AbstractRoad road;
6 public AbstractRoad Road
7 {
8 get
9 {
10 return road;
11 }
12 set
13 {
14 road = value;
15 }
16 }
17 public abstract void Run();
18
19 }
20 class Man : people
21 {
22 public override void Run()
23 {
24 Console.Write("男人开着");
25 Road.Run();
26 }
27 }
28
29 class WoMan : people
30 {
31 public override void Run()
32 {
33 Console.Write("女人开着");
34 Road.Run();
35 }
36 }
37}
客户端调用:
1 static void Main(string[] args)
2 {
3
4 //男人开着公共汽车在高速公路上行驶;
5 Console.WriteLine("=========================");
6
7 AbstractRoad Road3 = new SpeedWay();
8 Road3.Car = new Bus();
9
10 people p = new Man();
11 p.Road = Road3;
12 p.Run();
13
14 Console.Read();
15 }
效果及实现要点:
1.Bridge模式使用“对象间的组合关系”解耦了抽象和实现之间固有的绑定关系,使得抽象和实现可以沿着各自的维度来变化。
2.所谓抽象和实现沿着各自维度的变化,即“子类化”它们,得到各个子类之后,便可以任意它们,从而获得不同路上的不同汽车。
3.Bridge模式有时候类似于多继承方案,但是多继承方案往往违背了类的单一职责原则(即一个类只有一个变化的原因),复用性比较差。Bridge模式是比多继承方案更好的解决方法。
4.Bridge模式的应用一般在“两个非常强的变化维度”,有时候即使有两个变化的维度,但是某个方向的变化维度并不剧烈——换言之两个变化不会导致纵横交错的结果,并不一定要使用Bridge模式。
适用性:
在以下的情况下应当使用桥梁模式:
1.如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性,避免在两个层次之间建立静态的联系。
2.设计要求实现化角色的任何改变不应当影响客户端,或者说实现化角色的改变对客户端是完全透明的。
3.一个构件有多于一个的抽象化角色和实现化角色,系统需要它们之间进行动态耦合。
4.虽然在系统中使用继承是没有问题的,但是由于抽象化角色和具体化角色需要独立变化,设计要求需要独立管理这两者。
总结:
Bridge模式是一个非常有用的模式,也非常复杂,它很好的符合了开放-封闭原则和优先使用对象,而不是继承这两个面向对象原则。
桥接模式与装饰的区别:
装饰模式:
这两个模式在一定程度上都是为了减少子类的数目,避免出现复杂的继承关系。但是它们解决的方法却各有不同,装饰模式把子类中比基类中多出来的部分放到单独的类里面,以适应新功能增加的需要,当我们把描述新功能的类封装到基类的对象里面时,就得到了所需要的子类对象,这些描述新功能的类通过组合可以实现很多的功能组合 .
桥接模式:
桥接模式则把原来的基类的实现化细节抽象出来,在构造到一个实现化的结构中,然后再把原来的基类改造成一个抽象化的等级结构,这样就可以实现系统在多个维度上的独立变化 。
发表评论
-
JVM内存管理:深入垃圾收集器与内存分配策略
2012-09-29 09:40 944转自http://icyfenix.iteye.com ... -
javaVM 内存管理
2012-09-29 09:18 1064转自http://icyfenix.iteye.com/blo ... -
使用J2SE API读取Properties文件的六种方法
2012-03-15 11:46 9501。使用java.util.Properties ... -
java设计模式 -Decorator
2012-03-01 16:05 978//抽象构件角色 abstract public c ... -
设计模式------Decorator
2012-03-01 14:29 811一、学习装饰着模式 1、定义及作用 该模式以对 ... -
正则表达式学习
2011-12-31 09:56 1075//正则表达式去掉中文 public static vo ... -
System.gc()
2011-06-24 17:40 1040最近在在翻看java的Garbage Collection,即 ... -
java gc(转)
2011-06-24 16:07 979<%@ page contentType="t ... -
hibernate
2011-06-24 11:29 01.hibernate lazy, inverse, casc ... -
详解spring事务属性(转)
2011-06-10 10:46 852Spring声明式事务让我们从复杂的事务处理中得到解脱。使得我 ... -
spring心得(转)
2011-06-03 11:00 8481、spring原理 s ... -
实战Concurrent
2011-05-30 17:45 928编写多线程的程序一直都是一件比较麻烦的事情,要考虑很多事情,处 ... -
Memcached(转)
2011-05-30 17:32 967我对于Memcached的接触,还是在去年看了CSDN的一系列 ... -
动态创建代理(转)
2011-04-21 11:22 1064随着Proxy的流行,Sun把它纳入到JDK1.3实现了Jav ... -
代理模式(转)
2011-04-21 11:17 910代理模式是常用的Java 设计模式,它的特征是代理类与委托类有 ... -
工厂模式
2011-04-18 15:35 1091简单工厂,工厂方法和 ... -
java 通过反射获取泛型的类型
2011-03-24 13:34 32184jdk1.5开始支持泛型,所以我们有时需要把泛型里定义的对象的 ... -
java反射学习(转)
2011-03-22 15:51 1040Java提供了一套机制来动态执行方法和构造方法,以及数组操作等 ... -
java反射(转)
2011-03-22 15:29 981Java的反射机制是Java特 ... -
Quartz学习
2010-11-09 13:20 9391.与Spring集成 Spring中与quartz 的结合方 ...
相关推荐
在桥接模式下,ADSL ROUTER 只是一个普通网桥,其功能较简单,需要代理服务器或网关设备将局域网中的通信汇聚起来再连接到外部网络上。在路由模式下,ADSL ROUTER 具有自带的 PPPoE 拨号软件,并能提供 DHCP 服务、...
在桥接模式中,抽象类(Abstraction)不直接引用具体实现(Implementation),而是通过一个桥接类(Bridge)来引用,这样抽象部分与实现部分可以独立变化,提供了更大的灵活性。 首先,我们来看一下桥接模式的基本...
桥接模式(Bridge Pattern)是一种设计模式,它旨在将抽象部分和其实现部分分离,使得这两部分可以独立地进行变化。在C++编程中,桥接模式能够帮助开发者更好地管理和扩展复杂的类结构,减少类之间的耦合度。下面将...
以下是一个简单的C++桥接模式实例: ```cpp // 实现接口 class Implementor { public: virtual void operation() = 0; }; // 具体实现 class ConcreteImplementorA : public Implementor { public: void ...
1. **桥接模式**(Bridge Pattern): 桥接模式的核心思想是将抽象部分与实现部分分离,使它们可以独立变化。在绘图软件中,抽象部分可能是各种图形(如圆形、矩形),而实现部分则包含填充颜色、线条样式等具体细节...
下面是一个简单的桥接模式的实现例子: ```cpp // 操作类 class Action { public: virtual void doSomething() = 0; }; // 实体类 class Pen { public: Pen() : m_pAction(NULL) {} virtual ~Pen() { delete m_...
桥接模式(Bridge Pattern)是一种结构型设计模式,它的主要目的是将抽象部分与其实现部分解耦,使得它们可以独立地进行变化和发展。在C++编程中,这种模式的应用可以帮助我们构建灵活、可扩展的系统,尤其在面对...
桥接模式(Bridge Pattern)作为一种结构型设计模式,尤为擅长于处理和抽象化类的多个维度变化,通过将抽象部分与其实现部分解耦,从而使得两者可以独立地变化和发展。在《17 桥接模式:组装变频洗衣机.pdf》的深入...
c++设计模式-结构型模式-桥接模式;qt工程,c++简单源码; 桥接(Bridge)模式的定义如下:将抽象与实现分离,使它们可以独立变化。它是用组合关系代替继承关系来实现,从而降低了抽象和实现这两个可变维度的耦合度...
相比之下,桥接模式(Bridge Mode)同样采用无线方式连接两台路由器,但桥接后的无线信号会有自己的独立SSID,与主路由器的信号名称不同。这意味着用户在桥接模式下需要分别连接两个不同的无线网络,虽然这在家庭...
[GOF《设计模式》]图1Bridge模式结构图桥接模式将抽象部分与它的实现分离,使它们能够独立地变化。一个普通的开关控制的电灯、电风扇等等,都是桥接的例子。开关的目的是将设备打开或关闭。实际的开关可以是简单的双...
### 桥接模式详解 #### 一、概念与背景 **桥接模式**是一种用于降低软件系统中各个部分耦合度的设计模式。其核心思想是通过将抽象化(Abstraction)与其实现化(Implementation)分离开来,使得二者能够独立地变化...
桥接模式(Bridge Pattern)是一种结构型设计模式,它的主要目的是将抽象部分与其实现部分进行解耦,使得它们能够独立地变化和发展。在Java中,桥接模式常常用于处理那些具有多种实现方式的抽象概念,它通过引入一个...
- **过度设计**:在某些情况下,桥接模式可能会被认为是过度设计的解决方案,尤其是在抽象与实现之间关系较为简单的情况下。 #### 总结 桥接模式是一种非常实用的设计模式,尤其适用于需要在运行时动态改变实现...
桥接模式(Bridge Pattern)是一种结构型设计模式,它的核心思想是将抽象与其实现分离,使它们都可以独立变化。这种模式允许用户在不影响其他部分的情况下改变某些部分的行为或表现形式。在Java中,桥接模式通常用于...
总结来说,vmnetcfg是VMware虚拟化环境中不可或缺的一部分,特别是对于需要虚拟机直接接入物理网络的用户来说,桥接模式提供了一种简单而直接的解决方案。正确配置和使用vmnetcfg工具能确保虚拟机在桥接模式下的稳定...
- **桥接模式**:在桥接模式下,网关仅仅作为一个简单的数据转发器,不进行地址转换,所有的网络配置都由上层的路由器或网络设备完成。这种模式常用于需要更高性能或特定配置的情况下。 #### 三、天翼网关改为桥接...
但在某些情况下,为了更好地发挥路由器的性能或实现更复杂的网络配置,用户可能需要将光猫设置为桥接模式。本文将详细介绍烽火HG2201U V5.01版本光猫如何从路由模式转换为桥接模式,并提供一些实用技巧。 #### 二、...