手机软件何时统一--桥接模式

行程的天空2024-04-07 21:21

1.1 凭什么你的游戏我不能玩

2007年苹果手机尚未出世，机操作系统多种多样（黑莓、塞班、Tizen等），互相封闭。而如今，存世的手机操作系统只剩下苹果OS和安卓，鸿蒙正在稳步进场。

1.2 紧耦合的程序演化

手机硬件软件和PC硬件软件，现在有一个N品牌的手机，它有一个小游戏，M品牌的手机，它有一个小游戏.

代码结构图

package code.chapter22.bridge1;

public class Test {

    public static void main(String[] args) {

        System.out.println("**********************************************");       
        System.out.println("《大话设计模式》代码样例");
        System.out.println();       

        HandsetBrandNGame game=new HandsetBrandNGame();
        game.run();

        HandsetGame game2 = new HandsetBrandMGame();
        game2.run();

        System.out.println();
        System.out.println("**********************************************");
    }
}

// //手机品牌N的游戏
// class HandsetBrandNGame {
//     public void run(){
//         System.out.println("运行N品牌手机游戏");
//     }
// }

//手机游戏类
class HandsetGame{
    public void run(){
    }
}

//手机品牌M的游戏
class HandsetBrandMGame extends HandsetGame{
    public void run(){
        System.out.println("运行M品牌手机游戏");
    }
}
//手机品牌N的游戏
class HandsetBrandNGame extends HandsetGame{
    public void run(){
        System.out.println("运行N品牌手机游戏");
    }
}

如果我现在需要每个品牌都增加一个音乐播放功能，那就在每个品牌的下面增加一个子类。现在又来了一家新的手机品牌S,它也有游戏、通讯录、音乐播放器，那就增加手机品牌S类和三个下属功能子类，如果我需要增加""输入法"功能、拍照功能，再增加L品牌X品牌呢？

上面好像也解决不了问题。

"是呀，就像我刚开始学会用面向对象的继承时，感觉它既新颖又功能强大，所以只要可以用，就都用上继承。这就好比是'有了新锤子，所有的东西看上去都成了钉子。［DPE］'但事实上，很多情况用继承会带来麻烦。比如，对象的继承关系是在编译时就定义好了，所以无法在运行时改变从父类继承的实现。子类的实现与它的父类有非常紧密的依赖关系，以至于父类实现中的任何变化必然会导致子类发生变化。当你需要复用子类时，如果继承下来的实现不适合解决新的问题，则父类必须重写或被其他更适合的类替换。这种依赖关系限制了灵活性并最终限制了复用性 ［DP］。"

"是呀，我这样的继承结构，如果不断地增加新品牌或新功能，类会越来越多的。"

"在面向对象设计中，我们还有一个很重要的设计原则，那就是合成／聚合复用原则。即优先使用对象合成／聚合，而不是类继承［DP］。

1.3 合成/聚合复用原则

合成／聚合复用原则（CARP），尽量使用合成／聚合，尽量不要使用类继承。［ J&DP］

合成（Composition，也有翻译成组合）和聚合（Aggregation）都是关联的特殊种类。

聚合表示一种弱的'拥有'关系，体现的是A对象可以包含B对象，但B对象不是A对象的一部分；合成则是一种强的'拥有'关系，体现了严格的部分和整体的关系，部分和整体的生命周期一样［DPE］。比方说，大雁有两个翅膀，翅膀与大雁是部分和整体的关系，并且它们的生命周期是相同的，于是大雁和翅膀就是合成关系。而大雁是群居动物，所以每只大雁都是属于一个雁群，一个雁群可以有多只大雁，所以大雁和雁群是聚合关系。"

"合成／聚合复用原则的好处是，优先使用对象的合成／聚合将有助于你保持每个类被封装，并被集中在单个任务上。这样类和类继承层次会保持较小规模，并且不太可能增长为不可控制的庞然大物［DP］。就刚才的例子，你需要学会用对象的职责，而不是结构来考虑问题。其实答案就在之前我们聊到的手机与电脑的差别上。"

"哦，我想想看，手机是不同的品牌公司，各自做自己的软件，就像我现在的设计一样，而PC却是硬件厂商做硬件，软件厂商做软件，组合起来才是可以用的机器。你是这个意思吗？"

"很好，我很喜欢你提到的'组合'这个词，实际上，像'游戏''通讯录''MP3音乐播放'这些功能都是软件，如果我们可以让其分离与手机的耦合，那么就可以大大减少面对新需求时改动过大的不合理情况。"

"好的好的，我想想怎么弄，你的意思其实就是应该有个'手机品牌'抽象类和'手机软件'抽象类，让不同的品牌和功能都分别继承于它们，这样要增加新的品牌或新的功能都不用影响其他类了。"

结构图

"还剩个问题，手机品牌和手机软件之间的关系呢？

"我觉得应该是手机品牌包含手机软件，但软件并不是品牌的一部分，所以它们之间是聚合关系。"

结构图

1.4 松耦合的程序

package code.chapter22.bridge2;

public class Test {

    public static void main(String[] args) {

        System.out.println("**********************************************");       
        System.out.println("《大话设计模式》代码样例");
        System.out.println();       

        HandsetBrand ab;
        ab = new HandsetBrandMAddressList();
        ab.run();

        ab = new HandsetBrandMGame();
        ab.run();

        ab = new HandsetBrandNAddressList();
        ab.run();

        ab = new HandsetBrandNGame();
        ab.run();

        System.out.println();
        System.out.println("**********************************************");
    }
}

//手机品牌
class HandsetBrand{
    public void run(){
    }
}

//手机品牌M
class HandsetBrandM extends HandsetBrand{

}
//手机品牌N
class HandsetBrandN extends HandsetBrand{

}

//手机品牌M的游戏
class HandsetBrandMGame extends HandsetBrandM{
    public void run(){
        System.out.println("运行M品牌手机游戏");
    }
}
//手机品牌N的游戏
class HandsetBrandNGame extends HandsetBrandN{
    public void run(){
        System.out.println("运行N品牌手机游戏");
    }
}

//手机品牌M的通讯录
class HandsetBrandMAddressList extends HandsetBrandM{
    public void run(){
        System.out.println("运行M品牌手机通讯录");
    }
}
//手机品牌N的通讯录
class HandsetBrandNAddressList extends HandsetBrandN{
    public void run(){
        System.out.println("运行N品牌手机通讯录");
    }
}

"是呀，现在如果要增加一个功能，比如手机音乐播放功能，那么只要增加这个类就行了。不会影响其他任何类。类的个数增加也只是一个。"

"如果是要增加S品牌，只需要增加一个品牌子类就可以了。个数也是一个，不会影响其他类的改动。"

package code.chapter22.bridge3;

public class Test {

    public static void main(String[] args) {

        System.out.println("**********************************************");       
        System.out.println("《大话设计模式》代码样例");
        System.out.println();       

        HandsetBrand ab;
        ab = new HandsetBrandM();

        ab.setHandsetSoft(new HandsetGame());
        ab.run();

        ab.setHandsetSoft(new HandsetAddressList());
        ab.run();

        HandsetBrand ab2;
        ab2 = new HandsetBrandN();

        ab2.setHandsetSoft(new HandsetGame());
        ab2.run();

        ab2.setHandsetSoft(new HandsetAddressList());
        ab2.run();

        //向扩展开放，增加的功能
        HandsetBrand ab3;
        ab3 = new HandsetBrandS();
        
        ab3.setHandsetSoft(new HandsetMusicPlay());
        ab3.run();


        System.out.println();
        System.out.println("**********************************************");
    }
}

//手机软件
abstract class HandsetSoft{
    //运行
    public abstract void run();
}

//手机游戏
class HandsetGame extends HandsetSoft{
    public void run(){
        System.out.println("手机游戏");
    }
}

//手机通讯录
class HandsetAddressList extends HandsetSoft{
    public void run(){
        System.out.println("通讯录");
    }
}

//手机品牌
abstract class HandsetBrand{
    protected HandsetSoft soft;

    //设置手机软件
    public void setHandsetSoft(HandsetSoft soft){
        this.soft=soft;
    }

    //运行
    public abstract void run();
}

//手机品牌M
class HandsetBrandM extends HandsetBrand{
    public void run(){
        System.out.print("品牌M");
        soft.run();
    }
}
//手机品牌N
class HandsetBrandN extends HandsetBrand{
    public void run(){
        System.out.print("品牌N");
        soft.run();
    }
}

//手机音乐播放
class HandsetMusicPlay extends HandsetSoft{
    public void run(){
        System.out.print("音乐播放");
    }
}

//手机品牌S
class HandsetBrandS extends HandsetBrand{
    public void run(){
        System.out.print("品牌S");
        soft.run();
    }
}

"这显然也符合了我们之前的一个什么设计原则？"

"开放-封闭原则。这样的设计显然不会修改原来的代码，而只是扩展类就行了。但今天我感受最深的是合成／聚合复用原则，也就是优先使用对象的合成或聚合，而不是类继承。聚合的魅力无限呀。相比，继承的确很容易造成不必要的麻烦。"

"盲目使用继承当然就会造成麻烦，而其本质原因主要是什么？"

"我想应该是，继承是一种强耦合的结构。父类变，子类就必须要变。"

"OK，所以我们在用继承时，一定要在是'is-a'的关系时再考虑使用，而不是任何时候都去使用。"

"哈，当然，你看看刚才画的那幅图，两个抽象类之间有什么？像什么？"

"有一个聚合线，哈，像一座桥。"

"好，说得好，这个设计模式就叫作'桥接模式'。"

1.5 桥接模式

桥接模式（Bridge），将抽象部分与它的实现部分分离，使它们都可以独立地变化。 ［DP］

"这里需要理解一下，什么叫抽象与它的实现分离，这并不是说，让抽象类与其派生类分离，因为这没有任何意义。实现指的是抽象类和它的派生类用来实现自己的对象［ DPE］。就刚才的例子而言，就是让'手机'既可以按照品牌来分类，也可以按照功能来分类。"

按品牌分类实现结构图

按软件分类实现结构图

"由于实现方式有多种，桥接模式的核心意图是把这些实现独立出来，让它们各自变化。这就使得每种实现的变化不会影响其他实现，从而达到应对变化的目的。"

1.6 桥接模式基本代码

桥接模式（Bridge）结构图

package code.chapter22.bridge0;

public class Test {

    public static void main(String[] args) {

        System.out.println("**********************************************");       
        System.out.println("《大话设计模式》代码样例");
        System.out.println();       

        Abstraction ab;
        ab = new RefinedAbstraction();

        ab.setImplementor(new ConcreteImplementorA());
        ab.operation();

        ab.setImplementor(new ConcreteImplementorB());
        ab.operation();

        System.out.println();
        System.out.println("**********************************************");
    }
}

abstract class Implementor{
    public abstract void operation();
}


class ConcreteImplementorA extends Implementor{
    public void operation(){
        System.out.println("具体实现A的方法执行");
    }
}

class ConcreteImplementorB extends Implementor{
    public void operation(){
        System.out.println("具体实现B的方法执行");
    }
}


abstract class Abstraction{
    protected Implementor implementor;

    public void setImplementor(Implementor implementor){
        this.implementor = implementor;
    }

    public abstract void operation();
}

class RefinedAbstraction extends Abstraction{
    public void operation(){
        System.out.print("具体的Abstraction");
        implementor.operation();
    }
}

Implementor类：

ConcreteImplementorA和ConcreteImplementorB等派生类：Abstraction类：

RefinedAbstraction类：

"我觉得桥接模式所说的'将抽象部分与它的实现部分分离'，还是不好理解，我的理解就是实现系统可能有多角度分类，每一种分类都有可能变化，那么就把这种多角度分离出来让它们独立变化，减少它们之间的耦合。"也就是说，在发现我们需要多角度去分类实现对象，而只用继承会造成大量的类增加，不能满足开放-封闭原则时，就应该要考虑用桥接模式了。

1.7 我要开发"好"游戏

我要是有钱，就一定去买那种有操作系统，把软件与手机分离的智能手机，说不定我还可以自己开发手机游戏呢。

相关推荐
zquwei7 分钟前
SpringCloudGateway+Nacos注册与转发Netty+WebSocket
java·网络·分布式·后端·websocket·网络协议·spring
TT哇13 分钟前
*【每日一题 提高题】[蓝桥杯 2022 国 A] 选素数
java·算法·蓝桥杯
火烧屁屁啦36 分钟前
【JavaEE进阶】初始Spring Web MVC
java·spring·java-ee
w_31234541 小时前
自定义一个maven骨架 | 最佳实践
java·maven·intellij-idea
岁岁岁平安1 小时前
spring学习(spring-DI(字符串或对象引用注入、集合注入)(XML配置))
java·学习·spring·依赖注入·集合注入·基本数据类型注入·引用数据类型注入
武昌库里写JAVA1 小时前
Java成长之路（一）--SpringBoot基础学习--SpringBoot代码测试
java·开发语言·spring boot·学习·课程设计
Q_19284999061 小时前
基于Spring Boot的九州美食城商户一体化系统
java·spring boot·后端
张国荣家的弟弟1 小时前
【Yonghong 企业日常问题 06】上传的文件不在白名单，修改allow.jar.digest属性添加允许上传的文件SH256值？
java·jar·bi
ZSYP-S2 小时前
Day 15：Spring 框架基础
java·开发语言·数据结构·后端·spring
越甲八千2 小时前
重温设计模式--享元模式
设计模式·享元模式
热门推荐
01构建高效的广告投放系统：应用架构的设计与实现02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04Cube-Studio：开源大模型全链路一站式中台05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问07〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO