桥接模式讲解及例子
桥接模式(Bridge)
桥接模式（Bridge）1 场景问题1.1 发送提示消息考虑这样一个实际的业务功能：发送提示消息。
基本上所有带业务流程处理的系统都会有这样的功能，比如某人有新的工作了，需要发送一条消息提示他。
从业务上看，消息又分成普通消息、加急消息和特急消息多种，不同的消息类型，业务功能处理是不一样的，比如加急消息是在消息上添加加急，而特急消息除了添加特急外，还会做一条催促的记录，多久不完成会继续催促。
从发送消息的手段上看，又有系统内短消息、手机短消息、邮件等等。
现在要实现这样的发送提示消息的功能，该如何实现呢？1.2 不用模式的解决方案1：实现简化版本先考虑实现一个简单点的版本，比如：消息先只是实现发送普通消息，发送的方式呢，先实现系统内短消息和邮件。
其它的功能，等这个版本完成过后，再继续添加，这样先把问题简单化，实现起来会容易一点。
（1）由于发送普通消息会有两种不同的实现方式，为了让外部能统一操作，因此，把消息设计成接口，然后由两个不同的实现类，分别实现系统内短消息方式和邮件发送消息的方式。
此时系统结构如图1所示：图1 简化版本的系统结构示意图下面看看大致的实现示意。
（2）先来看看消息的统一接口，示例代码如下：Java代码1./**2. * 消息的统一接口3. */4.public interface Message {5. /**6. * 发送消息7. * @param message 要发送的消息内容8. * @param toUser 消息发送的目的人员9. */10. public void send(String message,String toUser);11.}（3）再来分别看看两种实现方式，这里只是为了示意，并不会真的去发送Email 和站内短消息，先看站内短消息的方式，示例代码如下：Java代码1./**2. * 以站内短消息的方式发送普通消息3. */4.public class CommonMessageSMS implements Message{5. public void send(String message, String toUser) {6. System.out.println("使用站内短消息的方式，发送消息'"7.+message+"'给"+toUser);8. }9.}同样的，实现以Email的方式发送普通消息，示例代码如下：Java代码1./**2. * 以Email的方式发送普通消息3. */4.public class CommonMessageEmail implements Message{5. public void send(String message, String toUser) {6. System.out.println("使用Email的方式，发送消息'"7.+message+"'给"+toUser);8. }9.}2：实现发送加急消息上面的实现，看起来很简单，对不对。
无线桥接图解(集中三种案例)概要
无线组网无线桥接图解(集中三种案例)目录：1、方法一：都带WDS功能的路由器实现无线桥接TP-link 无线路由器设置方法图解_无线桥接设置2、方法二：都只有Bridge功能，而没有WDS功能的路由器实现无线桥接TP-LINK无线组网――只有Bridge功能无线桥接图解3、方法三：1个带WDS功能另一个Bridge功能路由器实现无线桥接4、需要注意几点5、无线路由器应用的几种模式1.AP模式2.无线客户端模式3.点对点桥接模式（适用无线将2个有线局域网连接在一起）4.点对点桥接模式（无线将多个有线局域网连接在一起）5.无线中继模式本人搜集整理的比较粗，但集中起来比较大家学习，请勿用于商用。
方法一：都带WDS功能的路由器实现无线桥接TP-link 无线路由器设置方法图解_无线桥接设置详细出处参考：file:///C:/Documents%20and%20Settings/Administrator/桌面/TP-link%20无线路由器WDS设置方法图解_无线桥接设置_网络通讯_软件教学_脚本之家.htm随着无线网络的发展，现在越来越多的公司及企业都已经开始布局无线局域网，今天我们主要介绍下适合中小企业的无线路由器桥接或WDS功能。
文章以TP-link WR841N无线路由器设置为例，其它路由器参考设置思路进行设置。
上图所示为一小型企业无线网络，A、B、C三个部门如果只使用1个无线路由器，可能会出现一些计算机搜到信号很弱或者搜索不到信号，导致无法连接无线网络。
解决方法是：A、B、C三个部门各自连接一台无线路由器，三个无线路由器通过WDS连接就可以实现整个区域的完美覆盖、消除盲点。
配置思想：无线路由器B作为中心无线路由器，无线路由器A、C与无线路由器B建立WDS连接。
步骤如下：无线路由器的基本设置请参考：tp link无线路由器设置一、中心无线路由器B设置登陆无线路由器设置B管理界面，在无线设置-基本设置中设置“SSID号”、“信道”，如图：在“无线设置”——“无线安全设置”中设置无线信号加密信息记录无线路由器B设置后的SSID、信道和加密设置信息，在后续无线路由器A、C的配置中需要应用。
路由器常用的四种桥接方式
路由器常用的四种桥接方式方法一：接副路由器的WAN口1. 网线接法1) 首先确认路由器的WAN口和LAN口。
2) 网线一头接主路由器的LAN口，一头接副路由器的WAN口。
2. 先配置副路由器，这时先不要插入WAN口的线。
电脑接副路由器的LAN口（或者手机连接路由器WiFi），登陆路由器，改副路由器的IP地址。
一般在网络参数--LAN口设置下。
保存后须重启。
如主路由器IP192.168.1.1 ，副路由器就需要改为192.168.2.1或其他网段IP注：主路由器和副路由器需改成不同网段的IP，否则IP冲突桥接路由器无法上网。
改完需要重启，重启后要用改后的IP才能登录副路由器。
重启后重新登陆路由器。
3.打开WAN口设置。
WAN口连接设置可选择静态IP或动态IP。
1）选择动态IP后其他都不用设置。
2）选择静态IP须输入IP(从主路由器上获取的IP,自己设置，但IP 不可是主路由器DHCP分配范围内及网内其他设备占用的IP。
) 子网掩码都是255.255.255.0网关是主路由器地址。
DNS服务器建议输入主路由器wan状态获取到的DNS地址。
方法二：接副路由器的LAN口1.网线的接法网线一头接主路由器的LAN口，一头接副路由器的LAN口。
这样接法相当于将路由器用作交换机。
2.配置副路由器，这时先不要插入LAN口的线。
电脑接副路由器的LAN口，登陆路由器，最好改掉副路由器的IP 地址，方便以后需要登陆。
注：副路由器需改成主路由器同网段的不同IP，并且IP不可是主路由器DHCP分配范围内及网内其他设备占用的IP。
改完需要重启，重启后要用改后的IP才能登录副路由器。
3.关闭DHCP服务器点击不启用，保存即可。
注：关闭DHCP主要为防止自动获取到的IP和网内其他设备冲突。
大部分路由器默认的DHCP分配范围一样。
方法三：路由器无线中继1. 用电脑或手机连接路由器，查询路由器ip2. 进入路由器设置界面。
由于大多数路由器都是以192.168.1.1进入设置界面的。
无线路由器桥接方法
无线路由器桥接方法无线路由器桥接是将两个或多个无线路由器连接在一起，以扩大无线网络的覆盖范围或增加无线网络的容量。
桥接方法有很多种，下面我将介绍几种比较常用的无线路由器桥接方法。
1. 无线桥接模式（Wireless Bridge Mode）无线桥接模式是一种最常见的无线路由器桥接方法。
在这种模式下，一个无线路由器充当主路由器，其他的无线路由器作为从路由器桥接到主路由器。
主路由器连接到互联网，并为所有连接到它的无线设备提供网络访问。
从路由器通过无线信号连接到主路由器，并将其扩展的无线信号传播到其他设备。
这种方法非常适用于扩大无线网络的覆盖范围。
2. 有线桥接模式（Wired Bridge Mode）有时候，由于环境限制或其他原因，无法通过无线信号进行桥接。
此时，可以选择使用有线桥接模式。
在有线桥接模式下，主路由器和从路由器通过以太网电缆连接在一起，从路由器将网络信号传输到其他设备。
这种方法的优点是稳定性高，不受无线信号干扰的影响，适合对网络信号质量要求较高的场合。
3. 中继模式（Repeater Mode）中继模式是一种通过接收主路由器发出的无线信号，并在同一频段上转发信号的桥接方法。
中继器一般放置在主路由器和接收设备之间，可以增强无线信号的传输范围。
但是，中继模式会降低网络性能，因为它需要将信号转发两次。
因此，只适合用于扩大无线网络覆盖范围，而不适用于要求高速稳定连接的场合。
4. WDS桥接（WDS Bridge）WDS（无线分布式系统）桥接是一种通过无线信号连接多个无线路由器的桥接方法。
主路由器和从路由器通过WDS协议进行通信，并通过无线信号在相互之间传输数据。
这种方法可以扩展无线网络并减少信号干扰，但需要设备支持WDS 功能才能实现。
以上介绍了几种常见的无线路由器桥接方法，根据实际情况选择合适的方法可以扩大无线网络的覆盖范围或增加无线网络的容量。
无论选择哪种方法，都需要在配置无线路由器时正确设置桥接模式，并确保所有设备在同一无线频段上运行，避免信号干扰。
桥接模式讲解
桥接模式讲解嘿，咱今儿就来说说桥接模式。
你说这桥接模式啊，就好像是在不同的世界之间搭起一座神奇的桥。
想象一下，有两个完全不同的地方，一边是各种奇奇怪怪的形状，另一边是五颜六色的色彩。
如果没有这座桥，它们就各自为政，谁也不理谁。
但有了桥接模式这座桥呢，它们就能相互连接，产生出各种奇妙的组合。
咱就拿画画来打个比方吧。
形状就像是线条、轮廓，而色彩呢，就是那让画面变得绚丽多彩的颜料。
如果没有一个好的方式把它们结合起来，那画出来的东西可能就会很奇怪，对吧？桥接模式就是让这两者能够完美融合的关键。
再比如说，在一个大公司里，有不同的部门，研发部门搞技术，市场部门搞推广。
这就好像是两个不同的领域，如果没有一个好的沟通和协作机制，那很容易就会出现混乱。
这时候桥接模式就发挥作用啦，它让研发的成果能够顺利地传递到市场部门，让市场部门能更好地把产品推向客户。
你看，桥接模式多重要啊！它让看似不相关的东西能够连接起来，发挥出更大的作用。
就像把一颗颗散落的珍珠串起来，变成一条美丽的项链。
在我们的生活中，不也有很多这样的情况吗？比如我们的兴趣爱好和工作，如果能找到一个合适的桥接模式，说不定就能把爱好变成事业，那该多棒啊！或者是不同的人际关系，通过桥接模式能让大家更好地相处和合作。
而且啊，桥接模式还特别灵活。
它不是那种死板的连接，而是可以根据实际情况进行调整和变化。
就像那座桥可以变宽变窄，可以有不同的坡度，以适应不同的需求。
它让我们能够打破常规，不再局限于一种固定的模式。
这样我们就能有更多的创新和可能性啦！所以说啊，桥接模式可不是什么可有可无的东西，它是能让我们的世界变得更加丰富多彩的魔法呀！大家可千万别小瞧了它，要好好去发现和运用它，让我们的生活变得更加美好，更加有趣！这就是我对桥接模式的理解，你们觉得呢？。
设计模式之桥接模式（Bridge）详解及代码示例
设计模式之桥接模式（Bridge）详解及代码⽰例⼀、桥接模式的定义 桥接（Bridge）模式的定义如下：将抽象与实现分离，使它们可以独⽴变化。
它是⽤组合关系代替继承关系来实现，从⽽降低了抽象和实现这两个可变维度的耦合度。
⽐如设想如果要绘制矩形、圆形、椭圆、正⽅形，我们⾄少需要4个形状类，但是如果绘制的图形需要具有不同的颜⾊，如红⾊、绿⾊、蓝⾊等，此时⾄少有如下两种设计⽅案：第⼀种设计⽅案是为每⼀种形状都提供⼀套各种颜⾊的版本。
第⼆种设计⽅案是根据实际需要对形状和颜⾊进⾏组合。
采⽤⽅案⼆来进⾏设计系统中类的个数更少，且系统扩展更为⽅便。
设计⽅案⼆即是桥接模式的应⽤。
桥接模式将继承关系转换为关联关系，从⽽降低了类与类之间的耦合，减少了代码编写量。
⼆、桥接模式优缺点 桥接（Bridge）模式的优点是：由于抽象与实现分离，所以扩展能⼒强；其实现细节对客户透明。
缺点是： 由于聚合关系建⽴在抽象层，要求开发者针对抽象化进⾏设计与编程，这增加了系统的理解与设计难度。
三、桥接模式的实现 可以将抽象化部分与实现化部分分开，取消⼆者的继承关系，改⽤组合关系。
桥接（Bridge）模式包含以下主要⾓⾊。
抽象化（Abstraction）⾓⾊：定义抽象类，并包含⼀个对实现化对象的引⽤。
扩展抽象化（Refined Abstraction）⾓⾊：是抽象化⾓⾊的⼦类，实现⽗类中的业务⽅法，并通过组合关系调⽤实现化⾓⾊中的业务⽅法。
实现化（Implementor）⾓⾊：定义实现化⾓⾊的接⼝，供扩展抽象化⾓⾊调⽤。
具体实现化（Concrete Implementor）⾓⾊：给出实现化⾓⾊接⼝的具体实现。
其结构图如图所⽰： 其实现如下：public class BridgeTest{public static void main(String[] args){Implementor imple=new ConcreteImplementorA();Abstraction abs=new RefinedAbstraction(imple);abs.Operation();}}//实现化⾓⾊interface Implementor{public void OperationImpl();}//具体实现化⾓⾊class ConcreteImplementorA implements Implementor{public void OperationImpl(){System.out.println("具体实现化(Concrete Implementor)⾓⾊被访问" );}}//抽象化⾓⾊abstract class Abstraction{protected Implementor imple;protected Abstraction(Implementor imple){this.imple=imple;}public abstract void Operation();}//扩展抽象化⾓⾊class RefinedAbstraction extends Abstraction{protected RefinedAbstraction(Implementor imple){super(imple);}public void Operation(){System.out.println("扩展抽象化(Refined Abstraction)⾓⾊被访问" );imple.OperationImpl();}}四、桥接模式的应⽤实例 由于桥接模式上⾯描述⽐较抽象，此处再举⼀个关于包的例⼦进⾏分析：⼥⼠⽪包有很多种，可以按⽤途分、按⽪质分、按品牌分、按颜⾊分、按⼤⼩分等，存在多个维度的变化，所以采⽤桥接模式来实现⼥⼠⽪包的选购⽐较合适。
桥接模式的应用场景
桥接模式的应用场景1. 引言1.1 什么是桥接模式桥接模式是一种结构型设计模式，用于将抽象部分与实现部分分离，使它们可以独立变化而互不影响。
在桥接模式中，抽象部分和实现部分分别由抽象类和实现类来表示，它们通过桥接接口进行连接。
抽象类定义了对于操作的抽象方法，而实现类则实现了这些方法。
通过这种方式，客户端可以通过抽象类来调用实现类的方法，从而将具体的实现细节与抽象部分分离开来。
桥接模式的作用在于提高系统的灵活性和可维护性。
通过将两个独立变化的维度进行解耦，桥接模式使得系统能够更容易地应对变化，同时也能够更方便地扩展和修改。
桥接模式还能够使得系统更易于理解和维护，因为抽象部分和实现部分的关系变得清晰明了。
桥接模式是一种非常重要且实用的设计模式，能够在许多场景中发挥重要作用。
在接下来的内容中，我们将更详细地探讨桥接模式的特点和优势，以及它在实际应用中的具体场景和优势。
1.2 桥接模式的作用桥接模式的作用是将抽象部分与它的实现部分分离，使它们可以独立地变化。
通过桥接模式，可以实现多个维度的变化，从而提高系统的灵活性和可维护性。
具体来说，桥接模式可以帮助我们在不改变抽象部分的前提下，动态地改变其实现部分，从而满足不同的需求。
桥接模式还可以降低系统的复杂性，将系统划分为多个独立的部分，降低它们之间的耦合度。
桥接模式的作用主要体现在以下几个方面：分离抽象和实现、实现多个维度的变化、提高系统的灵活性和可维护性、降低系统的复杂性。
通过桥接模式，可以更好地管理系统中不同部分的变化，提高系统的可扩展性和可维护性。
桥接模式在软件开发中有着广泛的应用，可以用来处理各种不同的问题，提高系统的设计质量和开发效率。
在接下来的内容中，我们将深入探讨桥接模式的具体应用场景和优势，以及与其他模式的比较。
【2000字】2. 正文2.1 分离抽象和实现在桥接模式中，分离抽象和实现是一项重要的设计原则。
通过桥接模式，我们可以将抽象部分与实现部分分离，使它们可以独立变化，互不影响。
Python中的桥接模式
Python中的桥接模式Python中的桥接模式桥接模式是一种软件设计模式，通过将抽象部分与实现部分分离来实现解耦，使得两者可以独立地变化。
在Python中，桥接模式可以帮助我们优雅地解决面向对象编程中的一些常见问题，例如类的扩展性、代码的可读性和可维护性等。
1.桥接模式的基本概念桥接模式的核心思想是：将实现部分与抽象部分分离，使它们可以独立地变化。
在桥接模式中，抽象部分通常是一个抽象类或者接口，它定义了一些基本的功能和方法，但是没有具体的实现。
而实现部分则是一个或多个实现类，它们实现了抽象部分中定义的方法和功能。
通过抽象部分和实现部分之间的桥梁，我们可以将它们连接起来，达到解耦的目的。
桥梁通常是一个包含抽象部分对象和实现部分对象的组合对象。
通过桥梁对象，我们可以将抽象部分和实现部分有效地分离，从而实现更好的可扩展性和可维护性。
2.桥接模式的应用场景桥接模式通常适用于以下几种场景：（1）有多个相互独立的变化维度，且需要在运行时动态组合。
（2）需要隔离抽象部分和实现部分，使得它们可以独立地变化。
（3）需要跨越多个平台或者多个系统。
（4）需要实现松耦合的设计。
（5）需要支持扩展性和可维护性。
在Python中，桥接模式可以应用于很多地方，例如图形用户界面编程、网络编程、数据库编程等。
例如，在图形用户界面编程中，我们可以使用桥接模式来解耦控件和控件容器的关系。
控件容器可以是一个窗口、一个面板或者一个对话框，而控件可以是一个按钮、一个文本框或者一个列表框。
通过使用桥梁对象，我们可以将控件和控件容器有效地解耦，从而实现松耦合的设计。
3.一个桥接模式的示例——文本框和窗口的组合下面，我们通过一个简单的示例来介绍Python中桥接模式的应用。
这个示例演示了如何通过桥接模式将文本框和窗口的关系进行解耦。
首先，我们定义一个抽象类Component，它包含了一个抽象方法draw。
然后，我们定义两个具体的实现类：TextField和Window，它们分别实现了Component中的draw方法。
软件设计模式之桥接模式
软件设计模式之桥接模式桥接模式是一种结构性设计模式，用于将抽象与实现分离，使它们可以独立地变化。
该模式将抽象与实现通过一个桥接接口进行连接，实现了抽象和实现的解耦。
桥接模式主要解决了类之间的耦合性，将抽象与其实现分离开来，从而使得它们可以独立地进行变化。
具体而言，桥接模式将一个类的抽象部分与它的实现部分分离，使它们可以独立地进行变化，从而达到一个过程中改变抽象类和实现类的目的。
桥接模式包含以下几个关键角色：- 抽象类（Abstraction）：定义了抽象类的接口，维护了一个指向实现类接口的引用。
- 扩展抽象类（Refined Abstraction）：通过扩展抽象类来更加精细地定义抽象类的接口。
- 实现类接口（Implementor）：定义了实现类的接口。
- 具体实现类（Concrete Implementor）：实现了实现类接口并具体实现它。
下面以一个图形绘制的例子来说明桥接模式的使用。
假设有一个需要绘制图形的应用程序，该程序需要支持绘制不同形状的图形（如圆形、矩形等），且需要支持不同颜色的填充（如红色、蓝色等）。
使用桥接模式可以将图形的形状和颜色的填充进行解耦，使得它们可以独立地进行变化。
首先，定义一个抽象类Shape来表示图形，其中包含一个实现类接口Color作为成员变量来表示颜色的填充。
抽象类Shape定义了一个绘制方法draw，并在其中调用了Color接口的fillColor方法。
具体代码如下：```javapublic abstract class Shapeprotected Color color;public Shape(Color color)this.color = color;}public abstract void draw(;```然后，定义两个扩展抽象类Circle和Rectangle，分别代表圆形和矩形。
它们都继承自抽象类Shape，并实现了抽象方法draw，具体代码如下：```javapublic class Circle extends Shapepublic Circle(Color color)super(color);}public void draSystem.out.print("Circle ");color.fillColor(;}public class Rectangle extends Shapepublic Rectangle(Color color)super(color);}public void draSystem.out.print("Rectangle ");color.fillColor(;}```Color接口定义了一个fillColor方法，具体代码如下：```javapublic interface Colorvoid fillColor(;```最后，定义两个具体实现类RedColor和BlueColor，它们分别代表红色和蓝色的填充。
桥接模式的原理与实际项目中的应用场景
桥接模式的原理与实际项目中的应用场景桥接模式是一种软件设计模式，它旨在将抽象部分与其实现部分解耦，从而使它们可以独立地变化。
本文将介绍桥接模式的原理，并探讨在实际项目开发中的一些应用场景。
一、桥接模式的原理桥接模式的核心思想是将抽象与实现分离，通过一个抽象类（或接口）和一个实现类来实现这种分离。
抽象类定义了抽象部分的接口，而实现类则提供了具体的实现。
桥接模式通过这种方式实现了抽象和实现的解耦，使它们可以独立地变化。
具体而言，桥接模式包含以下角色：1. 抽象类（或接口）：定义了抽象部分的接口，其中可能包含一些抽象方法或成员变量。
2. 实现类：提供了具体实现部分的代码。
3. 桥接：将抽象类和实现类连接在一起，使它们可以协同工作。
桥接模式的原理可以通过以下示意图来表示：```+------------------+| 抽象类/接口 |+------------------+| +抽象方法 |+------------------+△|+------------------+| 实现类 |+------------------+| +具体实现 |+------------------+```通过桥接模式，抽象类和实现类可以分别独立地进行扩展和修改，而且它们之间的变化不会相互影响。
这样的架构设计具有很好的可维护性和可扩展性，并且便于进行单元测试和重构。
二、桥接模式的应用场景桥接模式在实际项目开发中有许多应用场景，下面将介绍其中的一些常见情况。
1. 数据库驱动程序在实际项目中，我们经常需要与各种不同的数据库进行交互。
桥接模式可以帮助我们将数据库的具体实现与抽象的数据库访问层解耦。
抽象数据库访问层定义了一些通用的数据库访问方法，而具体的数据库驱动程序提供了特定数据库的实现。
通过桥接模式，我们可以方便地切换和扩展不同的数据库驱动程序，而无需修改已经开发好的代码。
2. 操作系统的图形界面(GUI)在操作系统的图形界面开发中，我们经常需要跨平台支持不同的窗口、按钮和其他控件。
桥接(Bridge)模式【实验】
6.3.1 桥接模式的由来---案例2
A
XD1() XD2()
B
A
YD1() YD2()
B
X操作系统 XD1和XD2是X操作系统提供的接口
Y操作系统
返回目录
6.3.1 桥接模式的由来---案例2
A F(){ xd1(); xd2(); }
XD1() XD2()
A F(){ yd1(); yd2(); }
y操作系统
D1(){ xd1(); } D1(){ yd1(); }
用桥接模式解决前述问题
返回目录
6.3.1 桥接模式的由来---案例3
问题说明
返回目录
6.3.2 桥接模式的意图和适用性
传统地，当一个抽象可能有多个实现时，通常用 继承来协调它们。 抽象类定义该抽象的接口，而具体的子类则用不 同的方式加以实现。但是此方法有时不够灵活。 继承机制将抽象部分与它的实现部分固定在一起， 使得难以对抽象部分和实现部分独立地进行修改。 扩充和重用。 桥接模式的作用就是将抽象部分与实际部分分离， 使它可以独立的变化。
SuperSizeMilkcoffee
SuperSizeoriginalcoffee
pourCoffee
pourCoffee
Pouroneservingmilk(); for (int i = 0; i < 2; i++) { pouroneservingCoffee(); }
返回目录
6.3.1 桥接模式的由来---案例1
思考：加入咖啡可以添加橙汁、苹果汁，怎么办？ 增加小杯怎么办？
返回目录
6.3.1 桥接模式的由来---案例1
coffee
桥接模式
桥接模式(Bridge Pattern) 2011-08-25 一、桥梁（Bridge）模式桥梁模式是一个非常有用的模式，也是比较复杂的一个模式。
熟悉这个模式对于理解面向对象的设计原则，包括"开－闭"原则(OCP)以及组合/聚合复用原则(CARP)都很有帮助。
理解好这两个原则，有助于形成正确的设计思想和培养良好的设计风格。
桥梁模式的用意【GOF95】在提出桥梁模式的时候指出，桥梁模式的用意是"将抽象化(Abstraction)与实现化(Implementation)脱耦，使得二者可以独立地变化"。
这句话有三个关键词，也就是抽象化、实现化和脱耦。
抽象化存在于多个实体中的共同的概念性联系，就是抽象化。
作为一个过程，抽象化就是忽略一些信息，从而把不同的实体当做同样的实体对待【LISKOV94】。
实现化抽象化给出的具体实现，就是实现化。
脱耦所谓耦合，就是两个实体的行为的某种强关联。
而将它们的强关联去掉，就是耦合的解脱，或称脱耦。
在这里，脱耦是指将抽象化和实现化之间的耦合解脱开，或者说是将它们之间的强关联改换成弱关联。
将两个角色之间的继承关系改为聚合关系，就是将它们之间的强关联改换成为弱关联。
因此，桥梁模式中的所谓脱耦，就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以相对独立地变化。
这就是桥梁模式的用意。
二、桥梁模式的结构桥梁模式【GOF95】是对象的结构模式，又称为柄体(Handle and Body)模式或接口(Interface)模式。
下图所示就是一个实现了桥梁模式的示意性系统的结构图。
可以看出，这个系统含有两个等级结构，也就是：∙由抽象化角色和修正抽象化角色组成的抽象化等级结构。
∙由实现化角色和两个具体实现化角色所组成的实现化等级结构。
桥梁模式所涉及的角色有：∙抽象化(Abstraction)角色：抽象化给出的定义，并保存一个对实现化对象的引用。
桥接模式实例
桥接模式实例
桥接模式实例
1、实例⼀：模拟⽑笔
现需要提供⼤中⼩3种型号的画笔，能够绘制5种不同颜⾊，如果使⽤蜡笔，我们需要准备3*5=15⽀蜡笔，也就是说必须准备15个具体的蜡笔类。
⽽如果使⽤⽑笔的话，只需要3种型号的⽑笔，外加5个颜料盒，⽤3+5=8个类就可以实现15⽀蜡笔的功能。
本实例使⽤桥接模式来模拟⽑笔的使⽤过程
2、实例⼆：跨平台视频播放器
如果需要开发⼀个跨平台视频播放器，可以在不同操作系统平台（如Windows、Linux、Unix等）上播放多种格式的视频⽂件，常见的视频格式包括MPEG、RMVB、AVI、WMV等。
现使⽤桥接模式设计该播放器。
设计模式：桥接模式及代码示例、桥接模式在jdbc中的体现、注意事项
设计模式：桥接模式及代码⽰例、桥接模式在jdbc中的体现、注意事项0、背景加⼊⼀个⼿机分为多种款式，不同款式分为不同品牌。
这些详细分类下分别进⾏操作。
如果传统做法，需要将⼿机，分为不同的⼦类，再继续分，基本属于⼀个庞⼤的多叉树，然后每个叶⼦节点进⾏相同名称、但是细节不同的功能实现。
问题：类爆炸：类的增加基本没有任何优化，多⼀个就要妥妥的增加类；违反单⼀原则：增加⼀个品牌，影响每种类型下的这个品牌，增加⼀个类型，影响每个品牌的这个类型。
⼀、桥接模式解决上⾯说的问题的⽅式就是使⽤桥接模式。
桥接（Bridge）模式是指，将实现和抽象放在两个不同的类层次中，使得两个层次可以独⽴改变。
桥接模式是⼀种结构型设计模式，基于类的最⼩设计原则，让不同的类承担不同的职责。
（单⼀原则）桥接模式的主要特点是，把抽象 Abstraction 和⾏为实现 Implementation 分离开，从⽽保持各部分的独⽴和应对他们的功能扩展。
类图如下所⽰：其中，承担桥接功能的抽象类就是 Abstraction。
看起来还是很抽象，结合上⾯的⼿机问题，画出对应的类图，再结合来看：也就是说，⽐起原来的树状结构，⽤桥接模式，将⾏为实现放在⼀边，有⾃⼰的接⼝；将抽象出的另⼀个维度放在⼀边，有⾃⼰的抽象⽗类和⼦类，然后将上层的抽象类和实现接⼝相关联。
这样的话，前⾯遇到的问题:添加⼿机样式，就在左边添加抽象类定义就可以；添加品牌，在右边添加实现类就可以。
其他部分都不会被影响。
观察上⾯的图，桥接的意味也很明显，当 QuanPingPhone 使⽤⼀个 call ⽅法的时候，继承的其实是⽗类的⽅法，⽽这⾥⾯组合了另⼀个性质，⽐如是 Oppo ⼿机的 call ⽅法，那么就是通过桥接⼀路引过去的。
(忽略我的英语)按照这个思路我们来写⼀个实现：/*品牌，接⼝*/public interface Brand {void open();void close();void call();}public class Xiaomi implements Brand{@Overridepublic void open() {System.out.println("⼩⽶⼿机开机");}@Overridepublic void close() {System.out.println("⼩⽶⼿机关机");}@Overridepublic void call() {System.out.println("⼩⽶⼿机打电话");}}public class Vivo implements Brand{@Overridepublic void open() {System.out.println("vivo⼿机开机");}@Overridepublic void close() {System.out.println("vivo⼿机关机");}@Overridepublic void call() {System.out.println("vivo⼿机打电话");}}/*抽象层：⼿机，通过品牌接⼝聚合不同品牌*/public abstract class Phone {//品牌private Brand brand;public Phone(Brand brand) {this.brand = brand;}protected void open(){this.brand.open();}protected void close(){this.brand.close();}protected void call(){this.brand.call();}}/*折叠⼿机，继承抽象类⼿机*/public class BoldPhone extends Phone{//构造器public BoldPhone(Brand brand) {super(brand);}public void open(){super.open();//实际上通过⽗类的open，桥接到了brand下⾯的某个⼦类的openSystem.out.println("打开的是折叠⼿机");}public void close(){super.close();System.out.println("关闭的是折叠⼿机");}public void call(){super.call();System.out.println("打电话的的是折叠⼿机");}}/*全⾯屏⼿机，继承抽象类⼿机*/public class ScreenPhone extends Phone{public ScreenPhone(Brand brand) {super(brand);}public void open(){super.open();//实际上通过⽗类的open，桥接到了brand下⾯的某个⼦类的openSystem.out.println("打开的是全⾯屏⼿机");}public void close(){super.close();System.out.println("关闭的是全⾯屏⼿机");}public void call(){super.call();System.out.println("打电话的的是全⾯屏⼿机");}}调⽤试试：/*客户端*/public class Client {public static void main(String[] args) {//获取⼀个⼿机，需要的是样式+⼿机两个实现类//通过Phone这个抽象类，增加⼀个样式为BoldPhone的⼿机，桥接到品牌为XiaomiPhone phone = new BoldPhone(new Xiaomi());phone.open();phone.call();phone.close();}}这样的话，如果扩展起来，⽐如新增加⼀种样式的⼿机，我们只需要继承Phone再写⼀个⼦类，其余都不需要更改，如果新增加⼀个品牌的⼿机，只需要实现Band接⼝再写⼀个实现类，其余都不需要更改。
桥接模式——精选推荐
桥接模式⼿机操作问题现在对不同⼿机类型、不同品牌的⼿机实现操作编程(⽐如：开机、关机、上⽹，打电话等)传统⽅式实现类图:传统⽅案解决⼿机操作问题分析:1. 扩展性问题，如果我们再增加⼿机的样式(旋转式)，就需要增加各个品牌⼿机的类，同样如果我们增加⼀个⼿机品牌，也要在各个⼿机样式类下增加2. 违反了单⼀职责原则，当我们增加⼿机样式时，要同时增加所有品牌的⼿机，这样增加了代码维护成本3. 解决⽅案 --> 将⼿机的品牌和样式进⾏⽔平分割,并使⽤桥梁沟通,即使⽤桥接模式1. 桥接模式的基本介绍1. 桥接模式(Bridge模式)是指：将实现与抽象放在两个不同的类层次中，使两个层次可以独⽴改变，桥接模式是⼀种结构型设计模式2. Bridge模式基于类的最⼩设计原则，通过使⽤封装、聚合及继承等⾏为让不同的类承担不同的职责。
它的主要特点是把抽象(Abstraction)与⾏为实现(Implementation)分离开来，从⽽可以保持各部分的独⽴性以及应对他们的功能扩展桥接模式(Bridge)-原理类图1. Client：桥接模式的调⽤者2. Abstraction：抽象类，Abstraction 中维护了⼀个 Implementor 实现类的实例（聚合关系），Abstraction 充当桥接类3. RefinedAbstraction：Abstraction 的具体实现类,已经就与Implementor实现类桥接起来了4. Implementor：定义⾏为的接⼝5. ConcreteImplementor：Implementor 的具体实现类桥接模式和传统⽅式的对⽐1. 根据上⾯所述, 我们发现,在传统的⽅式中, ⼀个具体类的特性,都需要⾃⼰去通过继承体现,类的关系由继承完成,这样在类的数量上就成⼏何式增长,若品牌为三个,类型为四个,若想完整的实现所有的情况,就需要定义⼗⼆个类,2. 若使⽤上述描述中的桥接思想,我们只需将品牌和类型都以具体实现类的形式定义,再定义⼀个桥接类,分别持有品牌和类型属性. 对于不同的组合只需设置不同的属性即可2. 代码实现使⽤桥接模式改进传统⽅式，让程序具有更好的扩展性，利⽤程序维护类图:1. Brand：规定各个品牌⼿机的⾏为 ,和各个品牌的实现类//接⼝public interface Brand {void open();void close();void call();}public class XiaoMi implements Brand {@Overridepublic void open() {System.out.println(" ⼩⽶⼿机开机 ");}@Overridepublic void close() {System.out.println(" ⼩⽶⼿机关机 ");}@Overridepublic void call() {System.out.println(" ⼩⽶⼿机打电话 ");}}public class Vivo implements Brand {@Overridepublic void open() {System.out.println(" Vivo⼿机开机 ");}@Overridepublic void close() {System.out.println(" Vivo⼿机关机 ");}@Overridepublic void call() {System.out.println(" Vivo⼿机打电话 ");}}2. Phone：电话的抽象类，在该类中聚合了⼀个 Brand 接⼝的具体实现类 ,充当桥接的作⽤public abstract class Phone {// 组合品牌private Brand brand;// 构造器public Phone(Brand brand) {this.brand = brand;}protected void open() {this.brand.open();}protected void close() {this.brand.close();}protected void call() {this.brand.call();}}3. 继承抽象⽗类 Phone的各个款式的⼿机, 对抽象⽗类中的⽅法进⾏重写//折叠式⼿机类，继承抽象类 Phonepublic class FoldedPhone extends Phone {// 构造器public FoldedPhone(Brand brand) {super(brand);}@Overridepublic void open() {super.open();System.out.println(" 折叠样式⼿机 ");}@Overridepublic void close() {super.close();System.out.println(" 折叠样式⼿机 ");}@Overridepublic void call() {super.call();System.out.println(" 折叠样式⼿机 ");}}public class UpRightPhone extends Phone {// 构造器public UpRightPhone(Brand brand) {super(brand);}@Overridepublic void open() {super.open();System.out.println(" 直⽴样式⼿机 ");}@Overridepublic void close() {super.close();System.out.println(" 直⽴样式⼿机 ");}@Overridepublic void call() {super.call();System.out.println(" 直⽴样式⼿机 ");}}4. 客户端，可以看到，使⽤桥接模式可以轻松地组合出不同⼿机类型、不同品牌的⼿机public class Client {public static void main(String[] args) {// 折叠式的⼩⽶⼿机 (样式 + 品牌 )Phone phone1 = new FoldedPhone(new XiaoMi());phone1.open();phone1.call();phone1.close();System.out.println("=======================");// 折叠式的Vivo⼿机 (样式 + 品牌 )Phone phone2 = new FoldedPhone(new Vivo());phone2.open();phone2.call();phone2.close();System.out.println("==============");// 直⽴式的⼩⽶⼿机 (样式 + 品牌 )UpRightPhone phone3 = new UpRightPhone(new XiaoMi());phone3.open();phone3.call();phone3.close();System.out.println("==============");// 直⽴式的Vivo⼿机 (样式 + 品牌 )UpRightPhone phone4 = new UpRightPhone(new Vivo());phone4.open();phone4.call();phone4.close();}}总结:1. 可以看出,我们将品牌做成各个具体的实现类,使⽤Phone 作为桥梁,可以持有不同的品牌2. 因为此案例中只有两个属性,所以我们将款式的表⽰,体现为继承的⽅式 ,不同的款式,建⽴不同的类,继承抽象桥梁类Phone,也就可以持有不同的品牌了3. 若此时我们加了⼀个品牌或者加了⼀个款式,只需加⼀个类即可3. JDBC 源码分析Jdbc 的 Driver接⼝，如果从桥接模式来看， Driver就是⼀个接⼝（⾏为规范），下⾯可以有MySQL的Driver， Oracle的Driver，这些就可以当做实现接⼝类类图:1. 对于java定义的Connection 接⼝,不同的数据库有其相应的实现,Mysql Oracle 等2. 客户端通过桥接对象 DriverManager 去聚合各个数据源的实现类, 可以通过⽅法getConnection 获取@CallerSensitivepublic static Connection getConnection(String url,java.util.Properties info) throws SQLException {return (getConnection(url, info, Reflection.getCallerClass()));}4. 桥接模式的注意事项和细节1. 实现了抽象和实现部分的分离，从⽽极⼤的提供了系统的灵活性，让抽象部分和实现部分独⽴开来，这有助于系统进⾏分层设计，从⽽产⽣更好的结构化系统。
桥接模式
桥接模式例如:汽车类（Car），假设它有2个子类，卡车类（Truck）与公交车类（Bus），它们都有[配置引擎]这个动作，通过不同引擎规格的设置，可以将它们设置为,比如1500cc（Car1500）,和2000cc （Car2000）的车。
但是,不管是1500cc的卡车还是2000cc的卡车,或是1500cc的公交车还是2000cc的公交车，它们都可以是汽车类的子类。
但是,不管是卡车还是公交车，它们都有1500cc与2000cc引擎规格的车(车的种类即对象抽象类在变)。
然而汽车除了卡车，公交车之外，可能还有救火车,引擎规格除了有1500cc与2000cc之外，可能还有2500cc的车(汽车引擎规格及行为也在变)等等(有两个可变因素)。
这样一来，我们怎么来设计汽车类呢？方法一：通过继承设计所有可能存在的子类。
我们可能会想到下面的这种继承关系：汽车总类：Car汽车子类 - 按种类分类：Bus，Truck汽车子类 - 按引擎分类：Bus1500cc，Bus2000cc，Truck1500cc，Truck2000cc这样设置引擎这个动作就由各个子类加以实现。
但如果以后需要增加一种救火车（FireCar），以及增加一个引擎规格2500cc，需要实现的子类将会有： Bus1500cc，Bus2000cc，Bus2500cc，Truck1500cc，Truck2000cc，Truck2500cc，FireCar1500cc，FireCar2000cc，FireCar2500cc多达9个。
也就是说，这种设计方法，子类数目将随几何级数增长。
而且，Bus1500cc与Truck1500cc 的引擎规格相同，所以，它们的引擎设置动作应该是一样的，但现在把它们分成不同的子类，难以避免执行重复的动作行为。
方法二：分别为Bus以及Truck实现设置不同引擎的方法汽车总类：Car汽车子类：Bus，Truck然后在Bus类里分别提供1500cc以及2000cc引擎的设置方法：public class Bus extends Car {public setEngine1500cc();public setEngine2000cc();}在Truck类里也分别提供1500cc以及2000cc引擎的设置方法：public calss Truck extends Car {public setEngine1500cc();public setEngine2000cc();}这种情况，子类的数量是被控制了。
桥接模式的理解和应用案例
桥接模式的理解和应用案例桥接模式是一种设计模式，它将抽象部分与实现部分分离，使它们可以独立变化，互相之间不会影响。
它可以将一个大类或者一系列紧密相关的类拆分为抽象和实现两个独立的层次，使得它们可以分别变化而不会相互干扰。
通过桥接模式，我们可以更加灵活地组织和部署系统架构，提高系统的可扩展性和可维护性。
下面我们将围绕着桥接模式的理解和应用案例展开讲述。
一、桥接模式的概述桥接模式是对象的结构模式之一，它通过分离抽象，实现和它们之间的联系，可以在这些被分离的部分之间建立一个解耦的桥梁。
抽象部分是一个抽象类，它声明了一些抽象方法和属性，但是不提供具体的实现。
实现部分是一个实现类，它提供了具体的实现，但是不包括抽象部分。
桥接模式可以使得抽象部分和实现部分可以独立地改变和扩展，而不会相互影响。
桥接模式有以下几个角色：1. 抽象部分（Abstraction）：它是一个抽象类，定义了一些抽象方法和属性，但是不提供具体的实现。
它可以包含一个指向实现部分的指针，通过这个指针可以调用实现部分的方法。
2. 实现部分（Implementor）：它是一个接口或者一个抽象类，定义了一些具体的方法和属性。
它不包括抽象部分，但是可以通过抽象部分传递过来的参数来实现具体的功能。
3. 具体抽象部分（Refined Abstraction）：它是抽象部分的一个子类，定义了一些具体的方法和属性。
它通过调用父类的方法来实现抽象方法，同时也可以根据具体情况改变某些方法的实现。
4. 具体实现部分（Concrete Implementor）：它是实现部分的一个子类，定义了一些具体的方法和属性。
它通过实现父类的方法来提供具体的实现。
二、桥接模式的应用案例桥接模式的应用场景非常广泛，下面我们将介绍一个具体的案例。
假设我们要设计一个手机品牌的产品，其中有手机这个抽象类和手机品牌这个实现部分。
手机品牌有华为、小米、苹果等多个实现类，它们各自具有不同的特性和功能。
桥接设计模式实际应用
桥接设计模式实际应用桥接设计模式是一种常用的软件设计模式，它可以将抽象部分和实现部分分离开来，使得它们可以独立地变化。
这种设计模式在实际应用中非常常见，下面我们就来看看桥接设计模式在实际应用中的一些例子。
1. 操作系统和文件系统的桥接在操作系统中，文件系统是一个非常重要的组成部分。
不同的操作系统可能会采用不同的文件系统，例如Windows系统采用的是NTFS文件系统，而Linux系统采用的是ext4文件系统。
为了让不同的操作系统可以使用不同的文件系统，我们可以采用桥接设计模式。
具体来说，我们可以定义一个抽象的文件系统接口，然后让不同的操作系统去实现这个接口。
这样，不同的操作系统就可以使用不同的文件系统了。
2. 消息传递和网络传输的桥接在现代的软件系统中，消息传递和网络传输是非常常见的功能。
为了让不同的消息传递方式可以使用不同的网络传输方式，我们可以采用桥接设计模式。
具体来说，我们可以定义一个抽象的消息传递接口，然后让不同的网络传输方式去实现这个接口。
这样，不同的消息传递方式就可以使用不同的网络传输方式了。
3. 数据库和存储引擎的桥接在现代的软件系统中，数据库是一个非常重要的组成部分。
不同的数据库可能会采用不同的存储引擎，例如MySQL数据库采用的是InnoDB存储引擎，而Oracle数据库采用的是Oracle存储引擎。
为了让不同的数据库可以使用不同的存储引擎，我们可以采用桥接设计模式。
具体来说，我们可以定义一个抽象的存储引擎接口，然后让不同的数据库去实现这个接口。
这样，不同的数据库就可以使用不同的存储引擎了。
桥接设计模式在实际应用中非常常见，它可以帮助我们将抽象部分和实现部分分离开来，使得它们可以独立地变化。
如果你想要设计一个灵活、可扩展的软件系统，那么桥接设计模式是一个非常好的选择。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
/kalen_chen/archive/2007/05/21/1619498.aspx概述在软件系统中，某些类型由于自身的逻辑，它具有两个或多个维度的变化，那么如何应对这种“多维度”的变化？如何利用面向对象的技术来使得该类型能够轻松的沿着多个方向进行变化，而又不引入额外的复杂度？这就是要使用Bridge模式。
意图将抽象部分与实现部分分离，使它们都可以独立的变化。
结构图图1Bridge模式结构图生活中的例子桥接模式将抽象部分与它的实现分离，使它们能够独立地变化。
一个普通开关控制的电灯、电风扇等等，都是桥接的例子。
开关的目的是将设备打开或关闭。
实际的开关可以是简单的双刀拉链开关，也可以是调光开关。
图2使用电子开关例子的桥接对象图桥接模式解说在创建型模式里面，曾提到过抽象与实现，抽象不应该依赖于具体实现细节，实现细节应该依赖于抽象。
看下面这幅图：图3抽象不应该依赖于实现细节在这种情况下，如果抽象B稳定，而实现细节b变化，这时用创建型模式来解决没有问题。
但是如果抽象B也不稳定，也是变化的，该如何解决？这就要用到Bridge模式了。
我们仍然用日志记录工具这个例子来说明Bridge模式。
现在我们要开发一个通用的日志记录工具，它支持数据库记录DatabaseLog和文本文件记录FileLog两种方式，同时它既可以运行在.NET平台，也可以运行在Java平台上。
根据我们的设计经验，应该把不同的日志记录方式分别作为单独的对象来对待，并为日志记录类抽象出一个基类Log出来，各种不同的日志记录方式都继承于该基类：图4Log类结构图实现代码如下：public abstract class Log...{public abstract void Write(string log);}public class DatabaseLog : Log...{public override void Write(string log)...{//......Log Database}}public class TextFileLog : Log...{public override void Write(string log)...{//......Log Text File}}另外考虑到不同平台的日志记录，对于操作数据库、写入文本文件所调用的方式可能是不一样的，为此对于不同的日志记录方式，我们需要提供各种不同平台上的实现，对上面的类做进一步的设计得到了下面的结构图：实现代码如下：public class NDatabaseLog : DatabaseLog...{public override void Write(string log)...{//......(.NET平台)Log Database}}public class JDatabaseLog : DatabaseLog...{public override void Write(string log)...{//......(Java平台)Log Database}}public class NTextFileLog : TextFileLog...{public override void Write(string log)...{//......(.NET平台)Log Text File}}public class JTextFileLog : TextFileLog...{public override void Write(string log)...{//......(Java平台)Log TextFile}}现在的这种设计方案本身是没有任何错误的，假如现在我们要引入一种新的xml文件的记录方式，则上面的类结构图会变成：如图中蓝色部分所示，我们新增加了一个继承于Log基类的子类，而没有修改其它的子类，这样也符合了开放-封闭原则。
如果我们引入一种新的平台，比如说我们现在开发的日志记录工具还需要支持Borland平台，此时该类结构又变成了：同样我们没有修改任何东西，只是增加了两个继承于DatabaseLog和TextFileLog的子类，这也符合了开放-封闭原则。
但是这样的设计是脆弱的，仔细分析就可以发现，它还是存在很多问题，首先它在遵循开放-封闭原则的同时，违背了类的单一职责原则，集即一个类只有一个引起它变化的原因，而这里引起Log类变化的原因却有两个，即日志记录方式的变化和日志记录平台的变化；其次是重复代码会很多，不同的日志记录方式在不同的平台上也会有一部分的代码是相同的；再次是类的机构过于复杂，继承关系太多，难于维护；最后最致命的一点是扩展性太差。
上面我们分析的变化只是沿着某一个方向，如果变化沿着日志记录方式和不同的运行平台两个方向变化，我们会看到这个类的结构会迅速变得庞大。
现在该是Bridge模式粉墨登场的时候了，我们需要解耦这两个方面的变化，把它们之间的强耦合关系改成弱联系。
我们把日志记录方式和不同平台上的实现分别当作两个独立的部分来对待，对于日志记录方式，类结构图仍然是：现在我们引入另外一个抽象类ImpLog，它是日志记录在不同平台上实现的基类，结构图如下：实现代码如下：using System;using System.Collections.Generic;using System.Text;namespace BridgePattern...{/**//// <summary>/// 功能：ImpLog类/// 编写：Kalen_Chen/// 日期：2007年5月21日/// </summary>public abstract class ImpLog...{public abstract void Execute(string msg);}}using System;using System.Collections.Generic;using System.Text;namespace BridgePattern...{/**//// <summary>/// 功能：NImpLog类/// 编写：Kalen_Chen/// 日期：2007年5月21日/// </summary>public class NImpLog : ImpLog...{public override void Execute(string msg)...{Console.WriteLine(".NET平台:" + msg);}}}using System;using System.Collections.Generic;using System.Text;namespace BridgePattern...{/**//// <summary>/// 功能：JImpLog类/// 编写：Kalen_Chen/// 日期：2007年5月21日/// </summary>public class JImpLog : ImpLog...{public override void Execute(string msg)...{Console.WriteLine("Java平台:" + msg);}}}这时对于日志记录方式和不同的运行平台这两个类都可以独立的变化了，我们要做的工作就是把这两部分之间连接起来。
那如何连接呢?在这里，Bridge使用了对象组合的方式，类结构如下：实现代码如下：using System;using System.Collections.Generic;using System.Text;namespace BridgePattern...{/**//// <summary>/// 功能：Log类/// 编写：Kalen_Chen/// 日期：2007年5月21日/// </summary>public abstract class Log...{protected ImpLog implementor;public ImpLog Implementor...{set...{implementor = value;}}public virtual void Write(string log)...{implementor.Execute(log);}}}using System;using System.Collections.Generic;using System.Text;namespace BridgePattern...{/**//// <summary>/// 功能：DatabaseLog类/// 编写：Kalen_Chen/// 日期：2007年5月21日/// </summary>public class DatabaseLog :Log...{public override void Write(string log)...{implementor.Execute(log);}}}using System;using System.Collections.Generic;using System.Text;namespace BridgePattern...{/**//// <summary>/// 功能：TextFileLog类/// 编写：Kalen_Chen/// 日期：2007年5月21日/// </summary>public class TextFileLog :Log...{public override void Write(string log)...{implementor.Execute(log);}}}可以看到，通过对象组合的方式，Bridge模式把两个角色之间的继承关系改为了耦合的关系，从而使这两者可以从容自若的各自独立的变化，这也是Bridge模式的本意。
再来看一下客户端如何去使用：using System;using System.Collections.Generic;using System.Text;namespace BridgePattern...{/**//// <summary>/// 功能：客户端调用/// 编写：Kalen_Chen/// 日期：2007年5月21日/// </summary>class Program...{static void Main(string[] args)...{//.NET平台下的Database LogLog dblog = new DatabaseLog();dblog.Implementor = new NImpLog();dblog.Write("DatabaseLog");//Java平台下的Text File LogLog txtlog = new TextFileLog();txtlog.Implementor = new JImpLog();txtlog.Write("TextFileLog");Console.ReadLine();}}}可能有人会担心说，这样不就又增加了客户程序与具体日志记录方式之间的耦合性了吗？其实这样的担心是没有必要的，因为这种耦合性是由于对象的创建所带来的，完全可以用创建型模式却解决。