笨蛋学设计模式结构型模式-桥接模式【11】

结构型模式-桥接模式

    • 7.5桥接模式
      • 7.5.1概念
      • 7.5.2场景
      • 7.5.3优势 / 劣势
      • 7.5.4桥接模式可分为
      • 7.5.5外观模式
      • 7.5.6实战
        • 7.5.6.1题目描述
        • 7.5.6.2输入描述
        • 7.5.6.3输出描述
        • 7.5.6.4实战
      • 7.5.7总结
      • 桥接模式

7.5桥接模式

7.5.1概念

​ 桥接模式主要将抽象部分与实现部分分离开来,使得它们可以相互独立地变化。抽象部分定义了一个抽象类或接口,包含一些基本操作以及包含一个指向实现部分的引用。实现部分也是一个抽象类或接口,定义了一些具体的操作。

7.5.2场景

​ 比如在路上随处可见的汽车,汽车和引擎之间可以使用桥接模式。抽象部分可以是一个汽车的抽象类,实现部分可以是不同类型的汽车,如轿车、SUV等。而引擎可以是抽象部分的扩展类,实现部分可以是不同的引擎类型,如电动、燃油、混油引擎等。而我们可以创建多个引擎和汽车,而每个引擎和汽车之间都是独立的,通过桥接模式将不同类型的汽车和引擎进行组合,实现灵活的汽车配置。

7.5.3优势 / 劣势

  • 易维护:分离抽象和实现部分,使得系统更容易扩展和维护
  • 可复用性:提高系统的可复用性,使得在不同的系统中重用抽象 / 实现部分

  • 应用场景有限:主要适用于两个独立变化的维度,且维度之间都需要进行扩展
  • 增加理解难度:要求开发者针对抽象层进行编程,增加了理解和设计难度

7.5.4桥接模式可分为

  • 抽象Abstraction:一般是抽象类,定义抽象部分的接口,维护一个对实现的引用
  • 修正抽象RefinedAbstraction:对抽象接口进行扩展,通常对抽象化的不同维度进行变化或定制
  • 实现Implementor:定义实现部分的接口,提供具体的实现。该接口通常是抽象化接口的实现
  • 具体实现ConcreteImplementor:实现实现化接口的具体类,由这些类负责实现实现化接口定义的具体操作

7.5.5外观模式

package com.technologystatck.designpattern.mode.bridging;

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

        //创建具体实现化对象
        Implementor implementationA = new ConcreteImplementationA();
        Implementor implementationB = new ConcreteImplementationB();

        //使用扩充抽象化对象,将实现化对象传递进去
        Abstraction abstractionA = new RefinedAbstraction(implementationA);
        Abstraction abstractionB = new RefinedAbstraction(implementationB);

        //调用抽象化的操作
        abstractionA.operation();
        abstractionB.operation();

        System.out.println("--------------------------------------------");

        ATV atv = new ATV();
        BTV btv = new BTV();

        RemoteControl basicRemoteForA = new BasicRemoteControl(atv);
        RemoteControl basicRemoteForB = new BasicRemoteControl(btv);

        basicRemoteForA.turnOn();
        basicRemoteForA.turnOff();
        basicRemoteForA.tuneChannel();

        basicRemoteForB.turnOn();
        basicRemoteForB.turnOff();
        basicRemoteForB.tuneChannel();
    }
}

//创建实现接口
interface Implementor{
    void operationImpl();
}

//用电视举例,电视具有开关和切换频道的功能
interface TV{
    void on();
    void off();
    void tuneChannel();
}
//创建具体实现类:实际提供服务的对象
class ConcreteImplementationA implements Implementor{

    @Override
    public void operationImpl() {
        //具体实现A
        System.out.println("具体实现A");
    }
}

class ConcreteImplementationB implements Implementor{
    @Override
    public void operationImpl() {
        //具体实现B
        System.out.println("具体实现B");
    }
}

//用电视举例,创建具体实现类
class ATV implements TV{

    @Override
    public void on() {
        System.out.println("A TV is ON");
    }

    @Override
    public void off() {
        System.out.println("A TV is OFF");
    }

    @Override
    public void tuneChannel() {
        System.out.println("Turning A TV channel");
    }
}
class BTV implements TV{

    @Override
    public void on() {
        System.out.println("B TV is ON");
    }

    @Override
    public void off() {
        System.out.println("B TV is OFF");
    }

    @Override
    public void tuneChannel() {
        System.out.println("Turning B TV channel");
    }
}

//创建抽象类:包含一个对实现化接口的引用
abstract class Abstraction {
    protected Implementor implementor;

    public Abstraction(Implementor implementor) {
        this.implementor = implementor;
    }

    public void operation() {
        this.implementor.operationImpl();
    }
}
//用电视举例
abstract class RemoteControl{
    //持有一个实现化接口的引用
    protected TV tv;
    public RemoteControl(TV tv) {
        this.tv=tv;
    }

    abstract void turnOn();
    abstract void turnOff();
    abstract void tuneChannel();
}

//实现抽象类,创建RefinedAbstraction类
class RefinedAbstraction extends Abstraction {
    private Implementor implementor;


    public RefinedAbstraction(Implementor implementor) {
        super(implementor);
        this.implementor=implementor;
    }
    @Override
    public void operation() {
        this.implementor.operationImpl();
    }
}

class BasicRemoteControl extends RemoteControl{

    public BasicRemoteControl(TV tv) {
        super(tv);
    }

    @Override
    void turnOn() {
        tv.on();
    }

    @Override
    void turnOff() {
        tv.off();
    }

    @Override
    void tuneChannel() {
        tv.tuneChannel();
    }
}

7.5.6实战

7.5.6.1题目描述

小明家有一个万能遥控器,能够支持多个品牌的电视。每个电视可以执行开机、关机和切换频道的操作,请你使用桥接模式模拟这个操作。

7.5.6.2输入描述

第一行是一个整数 N(1 <= N <= 100),表示后面有 N 行输入。

接下来的 N 行,每行包含两个数字。第一个数字表示创建某个品牌的遥控和电视,第二个数字表示执行的操作。

其中,0 表示创建 Sony 品牌的电视,1 表示创建 TCL 品牌的遥控和电视;

2 表示开启电视、3表示关闭电视,4表示切换频道。

7.5.6.3输出描述

对于每个操作,输出相应的执行结果。

7.5.6.4实战
package com.technologystatck.designpattern.mode.bridging;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int nums = scanner.nextInt();
        scanner.nextLine();


        for(int i=0;i<nums;i++) {
            String[] input = scanner.nextLine().split(" ");
            int brand = Integer.parseInt(input[0]);
            int operation = Integer.parseInt(input[1]);

            //根据输入的不同,执行对应的操作
            UniversalRemoteTV universalRemoteTV= null;
            if(brand==0) {
                universalRemoteTV = new SonyTV();
            }else if(brand ==1) {
                universalRemoteTV = new TCLTV();

            }
            AbstractionTV abstractionTV=null;
            if(operation==2) {
                abstractionTV = new PowerOperation(universalRemoteTV);
            }else if(operation ==3) {
                abstractionTV = new OffOperation(universalRemoteTV);
            }else if (operation ==4) {
                abstractionTV = new ChannelOperation(universalRemoteTV);
            }

            abstractionTV.performOperation();

        }
    }
}

//定义实现接口
interface UniversalRemoteTV{
    //定义远程遥控电视的三个功能
    void onTV();
    void offTV();
    void channelTV();
}

//创建两个品牌电视具体实现类
class SonyTV implements UniversalRemoteTV{

    @Override
    public void onTV() {
        System.out.println("Sony TV is ON");
    }

    @Override
    public void offTV() {
        System.out.println("Sony TV is OFF");
    }

    @Override
    public void channelTV() {
        System.out.println("Switching Sony TV channel");
    }
}

class TCLTV implements UniversalRemoteTV{

    @Override
    public void onTV() {
        System.out.println("TCL TV is ON");
    }

    @Override
    public void offTV() {
        System.out.println("TCL TV is OFF");
    }

    @Override
    public void channelTV() {
        System.out.println("Switching TCL TV channel");
    }
}

//创建抽象类,对一个实现的引用
abstract class AbstractionTV{
    protected UniversalRemoteTV universalRemoteTV;

    public AbstractionTV(UniversalRemoteTV universalRemoteTV){
        this.universalRemoteTV = universalRemoteTV;
    }

    abstract void performOperation();

}

//创建扩充抽象化类
//打开电视操作
class PowerOperation extends AbstractionTV {


    public PowerOperation(UniversalRemoteTV universalRemoteTV) {
        super(universalRemoteTV);
    }

    @Override
    void performOperation() {
        universalRemoteTV.onTV();
    }
}
//关闭电视操作
class OffOperation extends AbstractionTV {

    public OffOperation(UniversalRemoteTV universalRemoteTV) {
        super(universalRemoteTV);
    }

    @Override
    void performOperation() {
        universalRemoteTV.offTV();
    }
}
//切换频道操作
class ChannelOperation extends AbstractionTV {

    public ChannelOperation(UniversalRemoteTV universalRemoteTV) {
        super(universalRemoteTV);
    }

    @Override
    void performOperation() {
        universalRemoteTV.channelTV();
    }
}

7.5.7总结

  • 桥接模式

  • 优点:方便将抽象部分和实现部分独立扩展,不需要修改另一个部分,减少系统的耦合度

  • 总结:将系统的功能分为抽象部分和实现部分,两个部分独立存在

  • 场景

    • 不希望使用继承,或者继承导致类爆炸性增长
    • 当一个类具有多个独立变化的维度时

你可能感兴趣的:(笨蛋学设计模式,设计模式,桥接模式,java)