设计模式--桥接(Bridge)模式

1.概述:

桥接模式:把抽象和行为分离开来,中间需要某个介质来连接抽象化和行为化。此模式的概述听起来非常像适配器模式,不要搞混了,虽然都是借用中间介质,但意义不同。

2.例子:

我们哪车子来打比方,比如:车有很多中类型(Bus,Jeep,taxi等),但每个车的引擎又不一样(有2000cc,2200cc)的;现在我们来造车,平常思维是根据车的配置来安装不同的引擎,而我们桥接模式的思维却是根据引擎来造车。

平常思维一:

/**
*造一个安装了引擎的车类接口
*/
package com.msit.xxx;

public interface Car {
    public void installEngine();// 安装 引擎
}
 1 /**
 2 *造一个Bus的具体车类,但每种Bus的引擎我们是不能立即确定的
 3 */
 4
 5 package com.msit.xxx;
 6
 7 /**
 8  * 公交车:需要哪种引擎就要增加哪种子类
 9  *
10  * @author admin
11  *
12  */
13 public abstract class Bus implements Car {
14
15     @Override
16     public abstract void installEngine();// 公交车又有2000cc发动机和2200cc发动机
17
18 }
 1 package com.msit.xxx;
 2 /**
 3 *造一辆2000cc的Bus
 4 */
 5 public class Bus2000 extends Bus {
 6
 7     @Override
 8     public void installEngine() {
 9         System.err.println("这是2000cc发动机Bus");
10     }
11 }
/**
*造一辆2200cc的Bus
*/
package com.msit.xxx;

public class Bus2200 extends Bus {

    @Override
    public void installEngine() {
        System.out.println("这是2200cc发动机Bus");
    }

}
package com.msit.xxx;

public class MainClass {
    public static void main(String[] args) {
        /**
         * 生产一辆2000cc的Bus
         */
        Car car1 = new Bus2000();
        car1.installEngine();

    }
}

这种实现方式的不足就是:每当我们的引擎或车的类型不确定时,或者增加(加一个1800cc的)引擎和车(造一辆吉普车)时,我们都需要写一个类实现Car,然后再继承具体车型;这样就会造成非常多的子类,显得项目非常的复杂。

平常思维二:

package com.msit.xxx2;
/**
*我们在造车的时候一并把引擎造出来,这样当某个车型需要哪种引擎就引用这种引擎
*/
public interface Car {
    // public void installEngine();原来的方法,产生一个总的引擎
    public void install2000Engine();

    public void install2200Engine();
        ......其他引擎
}
    
package com.msit.xxx2;

public class Bus implements Car {
    /**
     * 造汽车时,把引擎造出来
     */
    @Override
    public void install2000Engine() {
        System.out.println("2000cc发动机Bus");
    }

    @Override
    public void install2200Engine() {
        System.out.println("2200发动机Bus");
    }

}
package com.msit.xxx2;
/**
*生产汽车
*/
public class MainClass {
    public static void main(String[] args) {
        Car car = new Bus();
        car.install2000Engine();// 需要哪种引擎公交车就装哪种
    }
}

这种实现的特点就是:把子类具有的引擎集中在一起 ,需要哪种子类就增加哪种子类方法。但缺点时,有些引擎我们用不到却造出来了,这些方法就会变成一些冗余代码。

下面我们来用桥接模式做一下:

package com.msit.Birdge;

/**
 * 总引擎 桥接模式:以前是根据汽车来分引擎,现在是根据引擎来分汽车
 *
 * @author admin
 *
 */
public interface Engine {
    public void installEngine();

}
package com.msit.Birdge;
/**
*造一个具体的引擎
*/
public class Engine2000 implements Engine {

    @Override
    public void installEngine() {
        System.out.println("2000cc");
    }
}
package com.msit.Birdge;

public class Engine2200 implements Engine {

    @Override
    public void installEngine() {
        System.out.println("2200cc");
    }

}
package com.msit.Birdge;

/**
 * 设为抽象类的目的,根据不同车来配置引擎
 *
 * @author admin
 *
 */
public abstract class Car {
    private Engine engine;// 调用总引擎

    public Car(Engine engine) {
        this.engine = engine;
    }

    public Engine getEngine() {
        return engine;
    }

    public void setEngine(Engine engine) {
        this.engine = engine;
    }

    public abstract void installEngine();
}
package com.msit.Birdge;
/**
*开始设计车
*/
public class Bus extends Car {

    public Bus(Engine engine) {
        super(engine);
    }

    @Override
    public void installEngine() {
        System.out.println("Bus:");
        this.getEngine().installEngine();// 调用发动机,具体哪种发动机再安装的时候说明(使用Main方法的时候)
    }

}
package com.msit.Birdge;

/**
 * 开始生产
 *
 * @author admin
 *
 */
public class MainClass {
    public static void main(String[] args) {
        // 1.做一个具体的发动机出来
        Engine engine2000 = new Engine2000();
        Engine engine2200 = new Engine2200();
        // 2.做一个具体的车出来,并把具体引擎安上
        Car car = new Bus(engine2000);
        car.installEngine();

        Car car2 = new Bus(engine2200);
        car2.installEngine();

        // 想造什么类型的车并配上什么类型的引擎就直接new出来,不用产生那么多子类了。想做什么发动机就再做个
    }
}

桥接模式:把所有模子都做出来,在构造器上进行安装具体哪种模子,此时构造器就相当于一个桥接介质, 把抽象和行为分开了。

减少了子类和代码量,比如当我想再增加一个Jeep车时,就不需要增加那么多子类文件(引擎),而是安装一个总的Jeep车,再对引擎进行桥接。只需在main方法中这样写:

public class MainClass {
    public static void main(String[] args) {

        Car jeepCar = new Jeep(engine2000);
        jeepCar.installEngine();

        Car jeepCar2 = new Jeep(engine2200);
        jeepCar2.installEngine();
    }
}   
时间: 2024-10-10 07:05:43

设计模式--桥接(Bridge)模式的相关文章

C++设计模式实现--桥接(Bridge)模式

一. 举例 N年前: 计算机最先出来时,软件和硬件是一绑在一起的,比如IBM出了一台电脑,上面有一个定制的系统,假如叫 IBM_Win,这个IBM_Win系统当然不能在HP电脑上运行,同样HP出的HP_Win系统也不能运行在IBM上. 这时如果有一家新公司Apple出了一台新电脑,那么这个公司也要开发自己的系统 Apple_Win,Apple_Linux. 其实,上面几家公司开发的软件和硬件在很多地方都有相似之处,如果每家公司都做自己的系统,这意味着资源和人员的极大浪费. 这时,无论出现新的系统

Java 实现桥接(Bridge)模式

类图: /** * 手机壳.套 * @author stone * */ public abstract class BaseCellphoneShell { public abstract void mapping();//对应匹配哪种手机 } /** * 手机,桥接了 手机壳BaseCellphoneShell * @author stone */ public abstract class BaseCellphone { private BaseCellphoneShell shell;

23种设计模式(6)--Bridge模式

面向对象的设计原则:高内聚.低耦合 软件重构原则:小步快跑------抽取的思想(抽取函数.抽取类.抽取接口):对扩展开放.对修改封闭 设计模式分类如下: Bridge模式主要是解决多维度问题,什么意思呢?类似于n*m这个公式,n种抽象的接口,m种具体的实现,最多可以有n*m种组合方式. 下面这篇文章对Bridge模式讲解的通俗易懂,于是转了过来. 学习设计模式也有一段时间了,今天就把我整理的一篇课程和大家分享,有不妥之处欢迎指出. 生活中的一个例子: 就拿汽车在路上行驶的来说.即有小汽车又有公

漫谈设计模式(三):桥接(Bridge)模式 —— 将类功能、结构两层次分离

1.前言 类主要有两个层次,一个是功能层次,另一个是实现层次. 功能层次,一般应用于当前类不能满足多样化的业务需求,让子类去继承(具体)父类,添加加一些父类中没有的功能(一般是增加新的方法),这就属于因增加新功能而产生的层次结构. 实现层次,一般常见于子类去继承抽象类或接口,将抽象类或接口中的抽象方法重写,抽象类(接口)只声明了方法,而具体任务的分担需要子类去分担.相当于,子类只是将父类宣传出的口号.吹出的牛逼给落实了,将分配的任务给真正去做了,但它并没有增加新功能,只是实现父类的抽象方法,这就

设计模式之bridge模式

写在之前:设计模式的意义是解决 实际的设计问题,之所以不好理解是因为没有亲身的经历,所以要不停的学习实践思考. bridge翻译为桥接. 既然为桥接 则一定有桥接的两个对象.本文打算从三个方面来分析桥接模式. 1.桥接的两个对象是什么? 2.怎么样进行桥接 3.为什么要使用桥接模式. 1.桥接的两个对象是什么? 首先看桥接模式的定义:将一个类的抽象部分与实现部分分离,使它们都可以独立的变化.从这句话中科一粗略的知道桥接的对象 :一个类的抽象部分和实现部分. 2.为什么要进行桥接: 首先看一下设计

设计模式之Bridge模式(笔记)

桥接模式:将抽象部分与它的实现部分分离,使它们都可以独立的变化.抽象类和它的派生类用来实现自己的对象. 首先定义一个抽象实现类Implementor public abstract class Implementor { public abstract void operation(); } 接着定义具体2个的实现类继承Implementor类 public class ConcreteImplementA extends Implementor{ @Override public void o

设计模式之桥梁模式和策略模式的区别

桥接(Bridge)模式是结构型模式的一种,而策略(strategy)模式则属于行为模式.以下是它们的UML结构图. 桥梁模式: 策略模式: 在桥接模式中,Abstraction通过聚合的方式引用Implementor. 举一个例子: 策略模式:我要画圆,要实心圆,我可以用solidPen来配置,画虚线圆可以用dashedPen来配置.这是strategy模式. 桥接模式:同样是画圆,我是在windows下来画实心圆,就用windowPen+solidPen来配置,在unix下画实心圆就用uni

设计模式之桥梁模式和策略模式的差别

桥接(Bridge)模式是结构型模式的一种,而策略(strategy)模式则属于行为模式.下面是它们的UML结构图. 桥梁模式: 策略模式: 在桥接模式中,Abstraction通过聚合的方式引用Implementor. 举一个样例: 策略模式:我要画圆.要实心圆,我能够用solidPen来配置.画虚线圆能够用dashedPen来配置. 这是strategy模式. 桥接模式:相同是画圆,我是在windows下来画实心圆.就用windowPen+solidPen来配置.在unix下画实心圆就用un

设计模式之桥接模式(Bridge模式)

我想大家小时候都有用蜡笔画画的经历吧.红红绿绿的蜡笔一大盒,根据想象描绘出格式图样.而毛笔下的国画更是工笔写意,各展风采.而今天我们的故事从蜡笔与毛笔说起. 设想要绘制一幅图画,蓝天.白云.绿树.小鸟,如果画面尺寸很大,那么用蜡笔绘制就会遇到点麻烦.毕竟细细的蜡笔要涂出一片蓝天,是有些麻烦.如果有可能,最好有套大号蜡笔,粗粗的蜡笔很快能涂抹完成.至于色彩吗,最好每种颜色来支粗的,除了蓝天还有绿地呢.这样,如果一套12种颜色的蜡笔,我们需要两套24支,同种颜色的一粗一细.呵呵,画还没画,开始做梦了