【设计模式十四之桥梁模式】桥梁模式详解

最新推荐文章于 2023-04-19 13:57:31 发布

置顶 ^_^ 小小码nong

最新推荐文章于 2023-04-19 13:57:31 发布

阅读量407

点赞数

分类专栏： # 1：java设计模式文章标签：桥梁模式桥接模式 bridge pattern 桥接设计模式桥梁设计模式

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/qq_29924041/article/details/87867079

版权

1：java设计模式专栏收录该内容

26 篇文章 3 订阅

订阅专栏

Bridge Pattern 桥梁模式

细说桥梁模式
- 细说桥梁模式

细说桥梁模式

提示：
博主：章飞 _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();
	}
}

桥梁模式应用和注意事项

桥梁模式的狐妖是为了解决继承的缺点而设计出来的。实现抽象化和是实现化之间的解耦操作。是一种类似矩阵类型的组合模型。
桥梁模式的意图就是对变化的一种封装，尽量的把可能变化的因素封装设计到最小和最细的单元。
在桥梁模式设计模式中最主要的就是要拆分具体对象的特点，抽象出相关特点进行的。
适用于：一个类需要两个独立变化的维度，且两个维度都需要扩展

欢迎继续访问，我的博客