【设计模式十四之桥梁模式】桥梁模式详解
Bridge Pattern 桥梁模式
- 细说桥梁模式
- 细说桥梁模式
- 定义
- UML模型
- 场景
- 场景一
- 场景二
- 代码
- 代码一
- 代码二
- 基于UML的代码
- 桥梁模式应用和注意事项
细说桥梁模式
提示：
博主：章飞 _906285288的博客
博客地址：http://blog.csdn.net/qq_29924041
细说桥梁模式
定义
桥接（Bridge）模式又叫做桥梁模式，是用于把抽象化与实现化解耦，使得二者可以独立变化。这种类型的设计模式属于结构型模式，它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦
重点是解耦，这种解耦就是将两个不同属性的东西独立出去，从而实现分类组合的形式，举个例子，电子产品有很多，如手机，电脑，平板等等，对于厂商也有很多，比如苹果，华为，小米等等，假设我们要放在一个集合中列出的话，则有苹果手机，苹果电脑，苹果pad，华为手机，华为平板，华为电脑等等。。。。这样写的话，是不是耦合度特别高，那么就要求我们从另外一个维度去拆解，将其分为厂商类型和产品类型。使用矩阵排列的形式，进行两两组合。也就是将厂商和产品解耦了。类似
通过行和列的不同种类进行组合，从而穷举出不同的产品类型，而行，列所对应的其实就是桥接模式的两端
因此我的理解所谓的桥接模式，也就是类似矩阵穷举模型
在桥接模式中，最重要的其实就是单独抽离出组合类型的行，列。
UML模型
从图中可以看到。分为四个角色
1：Abstraction 抽象化的角色，重要定义出该角色的相关行为，同时保存一个实现化角色的引用，类似厂商角色
2：Implementor 实例化角色，定义出实例化角色的属性，类似产品类型
3：RedinedAbstraction 实现化的角色，主要是对抽象化角色的一种修正，类似小米，华为，苹果等实例化类
4：ConcreteImplementor 具体实现化的角色类型，类似平板，手机，电脑等实例化的角色
场景
场景一
第一个案例其实是来自设计模式之禅中，有一个山寨类型的工厂，这个工厂可以根据不同的需求随时去切换不同的产品，当需要生产衣服是，这个工厂就去生产衣服，当需要生产手机的时候，这个工厂就可以随时去切换成生产手机的工厂，当需要生产茶杯的时候，这个时候也可以随时切换成生产茶杯的工厂，这样，工厂不会随产品类型去修改。也就将工厂和产品进行了解耦。在这里，其实抽象的产品类型，也就是Implementor ，而山寨工厂则对应Abstraction
场景二
对于一些学美术的同学来说，对于画笔和颜料是要求的吧。如果现在我需要三种不同规格的画笔(细，中，粗)，然后每个画笔要有五中颜色(红，黄，蓝，绿，黑)，对于这个需求，有两种方案吧，一种就是我去买15支画笔。每个规格对应的颜色都来一支。但是这样成本是不是有点高啊。我每次都要买那么多。那就要想办法。类似我买三种不同规格可以改不同颜色的画笔。然后我再去买五中不同颜色的颜料。这样我通过两两组合的形式，是不是也可以达到目的。如果其中有一个损坏，或者不够的话。我就可以单买。如果我要添加一种颜色不同规格的画笔。这个时候用不着买三支笔，我只要增加一种颜色就行了。如果我再加一种规格的画笔。这样我就可以有这种规格下对应所有颜色的画笔。想一想。这样是不是会便捷很多很多
代码
代码一
定义一个抽象的公司类型，类似Abstraction
package src.com.zzf.designpattern.bridgepattern.demo1;
/**
* 定义抽象的产品类型
* @author Administrator
*
*/
public abstract class Crop {
public void makeMoney(){
produce();
sell();
}
public abstract void produce();
public abstract void sell();
}
定义一个抽象化的产品类型，类似Implementor
package src.com.zzf.designpattern.bridgepattern.demo1;
public interface Product {
public void beProduced();
public void beSelled();
}
具有修正意义的具体的RefinedAbstraction
package src.com.zzf.designpattern.bridgepattern.demo1;
public class ShanZhaiCrop extends Crop{
private Product mProduct;
public ShanZhaiCrop(Product mProduct){
this.mProduct = mProduct;
}
@Override
public void produce() {
// TODO Auto-generated method stub
mProduct.beProduced();
}
@Override
public void sell() {
// TODO Auto-generated method stub
mProduct.beSelled();
}
}
实例化角色，房子产品，类似ConcreteImplementor
package src.com.zzf.designpattern.bridgepattern.demo1;
public class HouseProduct implements Product{
public void beProduced() {
// TODO Auto-generated method stub
System.out.println("HouseProducted beProduced");
}
public void beSelled() {
// TODO Auto-generated method stub
System.out.println("HouseProducted beSelled");
}
}
实例化的服饰产品ConcreteImplementor2
package src.com.zzf.designpattern.bridgepattern.demo1;
public class ClothesProduct implements Product {
public void beProduced() {
// TODO Auto-generated method stub
System.out.println("ClothesProduct Produces");
}
public void beSelled() {
// TODO Auto-generated method stub
System.out.println("ClothesProducted beSelled");
}
}
测试代码
package src.com.zzf.designpattern.bridgepattern.demo1;
/**
*
*
* @author Administrator
*
*/
public class Client {
public static void main(String[] args) {
System.out.println("===========");
ShanZhaiCrop mShanZhaiCrop = new ShanZhaiCrop(new HouseProduct());
mShanZhaiCrop.makeMoney();
mShanZhaiCrop = new ShanZhaiCrop(new ClothesProduct());
mShanZhaiCrop.makeMoney();
}
}
代码二
package src.com.zzf.designpattern.bridgepattern.demo3;
/**
* 定义一个抽象的画笔类型
* @author zhangfei.zhou
*
*/
public abstract class PenShape {
Pigment mPigment;
public PenShape(Pigment pigment) {
// TODO Auto-generated constructor stub
this.mPigment = pigment;
}
public abstract void draw();
}
package src.com.zzf.designpattern.bridgepattern.demo3;
/**
* 修正的角色，粗体画笔
* @author zhangfei.zhou
*
*/
public class LargePenShape extends PenShape{
public LargePenShape(Pigment pigment) {
super(pigment);
// TODO Auto-generated constructor stub
}
@Override
public void draw() {
// TODO Auto-generated method stub
System.out.println(mPigment.pigmentName()+"粗画笔"+"draw");
}
}
package src.com.zzf.designpattern.bridgepattern.demo3;
/**
* 修正的角色，中粗画笔
* @author zhangfei.zhou
*
*/
public class MiddlePenShape extends PenShape{
public MiddlePenShape(Pigment pigment) {
super(pigment);
// TODO Auto-generated constructor stub
}
@Override
public void draw() {
// TODO Auto-generated method stub
System.out.println(mPigment.pigmentName()+"中粗画笔"+"draw");
}
}
package src.com.zzf.designpattern.bridgepattern.demo3;
/**
* 修正的角色，细画笔
* @author zhangfei.zhou
*
*/
public class SmallPenShape extends PenShape{
public SmallPenShape(Pigment pigment) {
super(pigment);
// TODO Auto-generated constructor stub
}
@Override
public void draw() {
// TODO Auto-generated method stub
System.out.println(mPigment.pigmentName()+"细画笔"+"draw");
}
}
package src.com.zzf.designpattern.bridgepattern.demo3;
/**
* 定义一个颜料的接口类型
* @author zhangfei.zhou
*
*/
public interface Pigment {
String pigmentName();
}
package src.com.zzf.designpattern.bridgepattern.demo3;
/**
* 颜料的实现类，黑色的颜料
* @author zhangfei.zhou
*
*/
public class BlackPigment implements Pigment {
@Override
public String pigmentName() {
// TODO Auto-generated method stub
return "黑色";
}
}
package src.com.zzf.designpattern.bridgepattern.demo3;
/**
* 颜料的实现类，蓝色的颜料
* @author zhangfei.zhou
*
*/
public class BluePigment implements Pigment {
@Override
public String pigmentName() {
// TODO Auto-generated method stub
return "蓝色";
}
}
package src.com.zzf.designpattern.bridgepattern.demo3;
/**
* 颜料的实现类，绿色的颜料
* @author zhangfei.zhou
*
*/
public class GreenPigment implements Pigment{
@Override
public String pigmentName() {
// TODO Auto-generated method stub
return "绿色";
}
}
package src.com.zzf.designpattern.bridgepattern.demo3;
/**
* 颜料的实现类，紅色的颜料
* @author zhangfei.zhou
*
*/
public class RedPigment implements Pigment {
@Override
public String pigmentName() {
// TODO Auto-generated method stub
return "红色";
}
}
package src.com.zzf.designpattern.bridgepattern.demo3;
/**
* 颜料的实现类，黃色的颜料
* @author zhangfei.zhou
*
*/
public class YellowPigment implements Pigment {
@Override
public String pigmentName() {
// TODO Auto-generated method stub
return "黄色";
}
}
package src.com.zzf.designpattern.bridgepattern.demo3;
public class TestClient {
public static void main(String[] args) {
PenShape penShape1 = new SmallPenShape(new RedPigment());
penShape1.draw();
PenShape penShape2 = new MiddlePenShape(new GreenPigment());
penShape2.draw();
PenShape penShape3 = new LargePenShape(new BlackPigment());
penShape3.draw();
}
}
基于UML的代码
package src.com.zzf.designpattern.bridgepattern.demo2;
public abstract class Abstraction {
Implementor mImplementor = null;
public Abstraction(Implementor mImplementor) {
// TODO Auto-generated constructor stub
this.mImplementor = mImplementor;
}
void request() {
mImplementor.doSomething();
}
public Implementor getImplementor() {
return mImplementor;
}
}
package src.com.zzf.designpattern.bridgepattern.demo2;
public interface Implementor {
void doSomething();
void doAnyThing();
}
package src.com.zzf.designpattern.bridgepattern.demo2;
public class RefinedAbstraction extends Abstraction{
public RefinedAbstraction(Implementor mImplementor) {
super(mImplementor);
// TODO Auto-generated constructor stub
}
@Override
void request() {
// TODO Auto-generated method stub
super.request();
super.getImplementor().doAnyThing();
}
}
package src.com.zzf.designpattern.bridgepattern.demo2;
public class ConcreteImplementor implements Implementor{
public void doSomething() {
// TODO Auto-generated method stub
System.out.println("ConcreteImplementor1 doSomething");
}
public void doAnyThing() {
// TODO Auto-generated method stub
System.out.println("ConcreteImplementor1 doAnyThing");
}
}
package src.com.zzf.designpattern.bridgepattern.demo2;
public class ConcreteImplementor2 implements Implementor{
public void doSomething() {
// TODO Auto-generated method stub
System.out.println("ConcreteImplementor2 doSomething");
}
public void doAnyThing() {
// TODO Auto-generated method stub
System.out.println("ConcreteImplementor2 doAnyThing");
}
}
package src.com.zzf.designpattern.bridgepattern.demo2;
public class Clinet {
public static void main(String[] args) {
Implementor mImplementor = new ConcreteImplementor();
Abstraction mAbstraction = new RefinedAbstraction(mImplementor);
mAbstraction.request();
}
}
桥梁模式应用和注意事项
桥梁模式的狐妖是为了解决继承的缺点而设计出来的。实现抽象化和是实现化之间的解耦操作。是一种类似矩阵类型的组合模型。
桥梁模式的意图就是对变化的一种封装，尽量的把可能变化的因素封装设计到最小和最细的单元。
在桥梁模式设计模式中最主要的就是要拆分具体对象的特点，抽象出相关特点进行的。
适用于：一个类需要两个独立变化的维度，且两个维度都需要扩展
欢迎继续访问，我的博客