23种设计模式(10)-桥接模式

野性酷女 2022-06-12 02:28 255阅读 0赞

桥接模式 (Bridge)  
一、定义  
    二、结构  
    三、具体案例  
1.传统方法  
2.使用桥接模式  
    四、应用场景

--------------------

**一、定义**

将抽象部分与实现(行为)部分分离，使它们都可以独立的变化。  
桥接模式的做法是把变化部分(实现)抽象出来，使变化部分与主类(抽象)分离开来，从而将多个维度的变化彻底分离。最后，提供一个管理类(如下面的引擎类)来组合不同维度上的变化，通过这种组合来满足业务的需要。

--------------------

**二、结构**

图-桥接模式结构图  
![这里写图片描述][20160130173210034]

--------------------

**三、具体案例**

本案例是实现汽车安装引擎的功能  
汽车有两种 奔驰和宝马  他们安装的引擎不同 怎么实现了？  
有两种方法

1.传统方法

public interface Car { 
    
        public void installEngine200();
    
        public void installEngine300();
    }
    
    
    public class Bwm implements Car { 
    
        @Override
        public void installEngine200() {
            System.out.println("Bwm车组装Engine200");
        }
    
        @Override
        public void installEngine300() {
            System.out.println("Bwm车组装Engine300");      
        }
    }
    
    
    public class Bwm implements Car { 
    
        @Override
        public void installEngine200() {
            System.out.println("Bwm车组装Engine200");
        }
    
        @Override
        public void installEngine300() {
            System.out.println("Bwm车组装Engine300");      
        }
    }
    
    
    public class Client { 
    
        public static void main(String[] args) {
            //奔驰车安装200引擎
            Car benz=new Benz();
            benz.installEngine200();
            //宝马车安装300引擎
            Car bwm=new Bwm();
            bwm.installEngine300();
        }
    }

运行结果：  
Benz车组装Engine200  
Bwm车组装Engine300

--------------------

**缺点: 只要在Car接口中增加一个引擎类型的方法 那么它的具体实现类中也得增加一个空实现(如果该车不需要这个引擎) 比如我再增加一个型号400的引擎 ,相应的奔驰和宝马中都得增加该方法 但是我奔驰车不需要这种引擎 这样是不是造成了代码的冗余 所以这种方法不好拓展，这就要用到第二种方法 ：桥接模式了**

**2.使用桥接模式**

Implementor : Engine 定义实现接口(也就是引擎接口)。

//与实现(行为)部分
    public interface Engine {
        public void addEngine();
    }

ConcreteImplementor :  Engine200 ;Engine300  实现 引擎接口中方法。

//具体实现接口
    public class Engine200 implements Engine { 
    
        @Override
        public void addEngine() {
            System.out.println("组装Engine200");
        }
    
    }

--------------------

public class Engine300 implements Engine { 
    
        @Override
        public void addEngine() {
            System.out.println("组装Engine300");
        }
    }

Abstraction : Car 定义抽象接口。

//抽象部分
    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 install();
    }

RefinedAbstraction :Benz ;Bwm 扩展 Abstraction 类。

public class Benz extends Car { 
        public Benz(Engine engine) {
            super(engine);
        }
    
        @Override
        public void install() {
            System.out.println("Benz车安装");
            this.getEngine().addEngine();
        }
    }

--------------------

public class Bwm extends Car { 
    
        public Bwm(Engine engine) {
            super(engine);
        }
        @Override
        public void install() {
            System.out.println("Bwm车安装");
            this.getEngine().addEngine();
        }
    }

测试代码

public class Client {
    
        public static void main(String[] args) {
            //创建实现(行为) ->Engine引擎
            //第一种 引擎 
            Engine engine200=new Engine200();
            //第二种 引擎
            Engine engine300=new Engine300();
            //创建抽象 ->车
            Car benz=new Benz(engine200);
            benz.install();
    
            Car bwm=new Bwm(engine300);
            bwm.install();
        }
    }

运行结果:  
Benz车安装  
组装Engine200  
Bwm车安装  
组装Engine300

--------------------

**四、应用场景**

1、如果你不希望在抽象和实现部分采用固定的绑定关系，可以采用桥接模式，来把抽象和实现部分分开，然后在程序运行期间来动态的设置抽象部分需要用到的具体的实现，还可以动态切换具体的实现。

2、如果出现抽象部分和实现部分都应该可以扩展的情况，可以采用桥接模式，让抽象部分和实现部分可以独立的变化，从而可以灵活的进行单独扩展，而不是搅在一起，扩展一边会影响到另一边。

3、如果希望实现部分的修改，不会对客户产生影响，可以采用桥接模式，客户是面向抽象的接口在运行，实现部分的修改，可以独立于抽象部分，也就不会对客户产生影响了，也可以说对客户是透明的。

4、如果采用继承的实现方案，会导致产生很多子类，对于这种情况，可以考虑采用桥接模式，分析功能变化的原因，看看是否能分离成不同的纬度，然后通过桥接模式来分离它们，从而减少子类的数目。

[20160130173210034]: /images/20220612/eee30bcd956e459f895a7d8130387057.png