第十五讲：桥接模式

转载

mob604756ec296f 2017-04-21 07:23:00

第十五讲：桥接模式_抽象类

第十五讲：桥接模式_子类_02

第十五讲：桥接模式_ide_03

package com.ibeifeng.eg1;
//不同巴士安装的引擎不同,有的是3000CC,有的是2200CC,2400cc.
public abstract class Bus implements Car{

   public abstract void installEngine(); 

}

package com.ibeifeng.eg1;

public class Bus2000 extends Bus{

    @Override
    public void installEngine() {
        // TODO Auto-generated method stub
        System.out.println("给Bus安装2000cc发动机");
    }
  
}

package com.ibeifeng.eg1;

public class Bus2200 extends Bus{

    @Override
    public void installEngine() {
        // TODO Auto-generated method stub
        System.out.println("给Bus安装2200cc发动机");
    }

}

package com.ibeifeng.eg1;

/**
 * 汽车
 * @author zhongzh
 *
 */
public interface Car {
    public  void  installEngine();
}

package com.ibeifeng.eg1;

public abstract class Jeep implements Car{

    
    public abstract  void installEngine();
    
}

package com.ibeifeng.eg1;

public class Jeep2000 extends Jeep{

    @Override
    public void installEngine() {
        // TODO Auto-generated method stub
        System.out.println("给Jeep安装2000cc发动机");
    }

}

package com.ibeifeng.eg1;

public class Jeep2200 extends Jeep{

    @Override
    public void installEngine() {
        // TODO Auto-generated method stub
        System.out.println("给Jeep安装2200cc发动机");
        
    }
    
}

package com.ibeifeng.eg1;
//问题1:类非常多,如果再有卡车的话,或者再增加一种发动机规格.
//这样添加的子类是以几何型增长的.
public class MainClass {
    public static void main(String[] args) {
        Car car1 = new Bus2000();
        car1.installEngine();
    }
}

//违反了开放封闭的原则

//如果增加了一种发动机规格,Bus又要修改了.Car的代码也要修改.
//另外如果接口定义的发动机规格Bus没有,为了保持接口的统一性不得不给Bus一个空的实现.这也是非常不好的.

package com.ibeifeng.eg2;
//违反了开放封闭的原则
//如果增加了一种发动机规格,Bus又要修改了.Car的代码也要修改.
//另外如果接口定义的发动机规格Bus没有,为了保持接口的统一性不得不给Bus一个空的实现.
public class Bus implements Car {

    @Override
    public void install2000Engine() {
        // TODO Auto-generated method stub
         System.out.println("给Bus安装2000cc发动机");
    }

    @Override
    public void install2200Engine() {
        // TODO Auto-generated method stub
         System.out.println("给Bus安装2200cc发动机");
    }

    @Override
    public void install2300Engine() {
        // TODO Auto-generated method stub
        System.out.println("给Bus安装2300cc发动机");
    }

}

package com.ibeifeng.eg2;

/**
 * 汽车
 * @author zhongzh
 *
 */
public interface Car {
    //public  void  installEngine();
    public  void  install2000Engine();
    public  void  install2200Engine();
    public  void  install2300Engine();

 

}

package com.ibeifeng.eg2;

public class MainClass {
   public static void main(String[] args) {
       Car car1 =  new Bus();
       car1.install2000Engine();
}
}

Car(抽象)持有Engine(发动机)(行为)的引用,这就是聚合.Car和Engine都有继承,它们也有封装.所以桥接模式使用了封装、聚合和继承.

第十五讲：桥接模式_子类_04

第十五讲：桥接模式_ide_05

Abstraction:抽象. Car

RefinedAbstraction: Bus和Jeep.

Implementor:行为 Engine(引擎).

ConcreteImplementorA:实际的行为. 2000cc/2200cc

ConcreteImplementorB:实际的行为.

第十五讲：桥接模式_ide_06

不是一定要先做Engine再做Car,它们之间是相互独立的.它们之间有一座桥,这座桥就是一个聚合.Implementor是斜写的,抽象类.

桥接模式就很有扩展性.就算再添加一个卡车.那就再做一个卡车就行了,里面持有一个发动机的引用.

第十五讲：桥接模式_客户端_07

        //这样程序就很有扩展性.就算再添加一个卡车.那就再做一个卡车就是了,里面持有一个发动机的引用.
        //如果添加一个发动机,再做一个发动机就可以了.
        //只是客户端在调用的时候稍微麻烦一些,但是这种麻烦并不是特别麻烦,也是需要判断的.
        //客户端必须判断要支持一个什么样的实例,客户端必须得做的,你是实现哪一个实例/车的.
        //第二种方案客户端必须知道你调用哪一个方法,但是桥接模式客户端只要知道传哪一个发动机进去就行了.
        //客户端的判断是不可避免的.车的种类决定了你是要买2000的还是2200的还是买其他发动机规格的车.
        //桥接就在于Car里面持有Engine的引用.正是因为有了这个引用的存在,Car和Engine联系在一起.
        //Car持有Engine的接口的引用,可以传递不同的实现子类给它.因为有了不同的实现子类,又有了共同的接口,
        //所以可以实现不同的方法.
        //抽象和行为相互独立,而用桥(引用)将抽象和行为联系起来以后更加方便了,抽象和行为各自增加都不会产生任何的
        //影响,这就是桥的作用,它们之间是一个引用的关系.Abstraction包含/持有了Implementor的引用.
        //而且它们是一个接口,它们之间的方法是公开的公共的.

package com.ibeifeng.eg3;

public class MainClass {
     public static void main(String[] args) {
        Engine engine2000 = new Engine2000();
        Engine engine2200 = new Engine2200();
        
        //更加灵活,把抽象与行为分开.
        Car car1 = new Bus(engine2000);//Bus是要做什么引擎的,就把什么引擎传进去.
        car1.installEngine();
        Car car2 = new Bus(engine2200);//Bus是要做什么引擎的,就把什么引擎传进去.
        car2.installEngine();
        //把发动机规格传进去就可以了.
        
        Car jeep1 = new Jeep(engine2000);
        jeep1.installEngine();//给jeep安装2000cc发动机
        Car jeep2 = new Jeep(engine2000);
        jeep1.installEngine();//给jeep安装2200cc发动机
        //这样程序就很有扩展性.就算再添加一个卡车.那就再做一个卡车就是了,里面持有一个发动机的引用.
        //如果添加一个发动机,再做一个发动机就可以了.
        //只是客户端在调用的时候稍微麻烦一些,但是这种麻烦并不是特别麻烦,也是需要判断的.
        //客户端必须判断要支持一个什么样的实例,客户端必须得做的,你是实现哪一个实例/车的.
        //第二种方案客户端必须知道你调用哪一个方法,但是桥接模式客户端只要知道传哪一个发动机进去就行了.
        //客户端的判断是不可避免的.车的种类决定了你是要买2000的还是2200的还是买其他发动机规格的车.
        //桥接就在于Car里面持有Engine的引用.正是因为有了这个引用的存在,Car和Engine联系在一起.
        //Car持有Engine的接口的引用,可以传递不同的实现子类给它.因为有了不同的实现子类,又有了共同的接口,
        //所以可以实现不同的方法.
        //抽象和行为相互独立,而用桥(引用)将抽象和行为联系起来以后更加方便了,抽象和行为各自增加都不会产生任何的
        //影响,这就是桥的作用,它们之间是一个引用的关系.Abstraction包含/持有了Implementor的引用.
        //而且它们是一个接口,它们之间的方法是公开的公共的.
        
        
        
    }
}

package com.ibeifeng.eg3;

//public class Engine {
public interface Engine{
    public void installEngine();
    
    
    
}

package com.ibeifeng.eg3;

public class Engine2000 implements Engine{

    @Override
    public void installEngine() {
        // TODO Auto-generated method stub
        System.out.println("安装2000cc发动机");
    }

}

package com.ibeifeng.eg3;

public class Engine2200 implements Engine{

    @Override
    public void installEngine() {
        // TODO Auto-generated method stub
        System.out.println("安装2200cc发动机");
    }

}

package com.ibeifeng.eg3;
//这里把Car不做成接口,做成抽象类.
//Car持有Engine的引用.
//抽象类是没有实例的.
public abstract class Car {
    private Engine engine;

    public Car(Engine engine) {
        super();
        this.engine = engine;//把engine设置上.
    }
    
    public Engine getEngine() {//获得Car里面的发动机类型.
        return engine;
    }

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

    public  abstract void installEngine();//因为每个汽车安装的引擎是不同的.
}

package com.ibeifeng.eg3;

public class Bus extends Car {

    public Bus(Engine engine) {
        super(engine);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void installEngine() {
        // TODO Auto-generated method stub
        System.out.println("Bus:");
        
        this.getEngine().installEngine();//行为实现类接口.Abstraction(Car)接口定义了基于
        //Implementor接口(Engine)的更高层次的操作.
        //除了安装引擎之外,还打印了巴士.
    }

}

package com.ibeifeng.eg3;

public class Jeep extends Car {

    public Jeep(Engine engine) {
        super(engine);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void installEngine() {
        // TODO Auto-generated method stub
        System.out.println("Jeep:");
        this.getEngine().installEngine();
    }

}