细说桥梁模式
提示:
博主:章飞 _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();
}
}
桥梁模式应用和注意事项
桥梁模式的狐妖是为了解决继承的缺点而设计出来的。实现抽象化和是实现化之间的解耦操作。是一种类似矩阵类型的组合模型。
桥梁模式的意图就是对变化的一种封装,尽量的把可能变化的因素封装设计到最小和最细的单元。
在桥梁模式设计模式中最主要的就是要拆分具体对象的特点,抽象出相关特点进行的。
适用于:一个类需要两个独立变化的维度,且两个维度都需要扩展
欢迎继续访问,我的博客