拓拓的博客

coding....

Java实现桥接模式

22.2 紧耦合程序演化

两个手机品牌,都有游戏,两个手机是不同的操作系统。怎么写?
该有一个父类手机品牌游戏,让N和M品牌手机游戏都继承它。

如果N和M品牌手机又都增加了通讯录功能呢?
这里写图片描述

基于这个模型,那如果新增加一个手机品牌,并且每个手机品牌增加各种功能,例如:游戏、通讯录、MP3等。

那样就会变得非常麻烦。

继承的问题
无法在运行时改变从父类继承的实现,子类和父类依赖关系紧密,父类中任何变化都会导致子类发生变化。
当复用子类时,如果继承下来的子类不适合解决新问题,则父类必须重写或被其他更适合的类替换,导致限制了复用性。

面向对象中首先使用合成/聚合复用原则,即优先使用对象合成/聚合,而不是类继承。

22.3 合成/聚合复用原则

聚合
表示“弱”的拥有关系,A对象可包含B对象,但B对象不是A对象的一部分;
合成
是一种“强”的拥有关系,部分和整体的生命周期是一样的。

大雁和翅膀就类似于合成关系;每只大雁是属于一个雁群,一个雁群有多只大雁,所以大雁和雁群是聚合关系。
这里写图片描述

好处
优先使用对象的合成/聚合有助于你保持每个类被封装,并被集中在单个任务上。这样类和类继承层次会保持较小规模,且不太可能增长为不控制的庞然大物。

22.4 松耦合的程序

根据这个原则,修改之前的类结构。
这里写图片描述
手机品牌包含有手机软件,但软件不是品牌的一部分,所以是聚合关系。

手机软件

public abstract class HandsetSoft {
    public abstract void run();
}

游戏、通讯录等具体类

public class HandsetGame extends HandsetSoft {

    @Override
    public void run(){
        println("游戏");
    }
}

public class HandsetAddress extends HandsetSoft {

    @Override
    public void run(){
        println("通讯录");
    }
}

手机品牌类

public abstract class HandsetBrand {
    //弱聚合
    protected HandsetSoft soft;

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

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

品牌N品牌M等具体类

//品牌N
class HandsetBrandN extends HandsetBrand {

    @Override
    public void run(){
        soft.run();
    }
}

//品牌M
class HandsetBrandM extends HandsetBrand {

    @Override
    public void run(){
        soft.run();
    }
}

客户端

public class Main {
    HandsetBrand ab;
    //创建品牌N
    ab = new HandsetBrandN();

    //给品牌N安装游戏
    ab.setHandsetSoft(new HandsetGame());
    ab.run();

    //给品牌N安装通讯录
    ab.setHandsetSoft(new HandsetAddress());
    ab.run();
}

22.5 桥接模式

将抽象部分和它的实现部分分离,使它们都可以独立的变化。

就像之前例子,让手机既可以按品牌分类,也可以按功能来分类。
这里写图片描述
Implementor类

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

ConcreteImplementorA和ConcreteImplementorB等派生类

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

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

Abstraction类

public abstract class Abstraction {
    protected Implementor impl;

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

    public abstract void operation();
}

RefinedAbstraction类

public class RefinedAbstraction extends Abstraction {
    public RefinedAbstraction(Implementor impl){
        super(impl);
    }

    @Override
    public void operation(){
        impl.operation();
    }
}

客户端实现

public class Main {
    public static void main(String[] args){
        Abstraction ab = new RefinedAbstraction(new ConcreteImplementorA());
        ab.operation();

        ab = new RefinedAbstraction(new ConcreteImplementorB());
        ab.operation();
    }
}
阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载哦。 https://blog.csdn.net/a464700300/article/details/79956617
文章标签: 设计模式
个人分类: 设计模式
上一篇Redis持久化机制介绍
下一篇Java多线程编程核心技术--第2章 对象及变量的并发访问
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭