首页 > 其他分享 >简明设计模式---桥接模式

简明设计模式---桥接模式

时间:2022-09-24 23:55:05浏览次数:46  
标签:style 桥接 void class --- println shadow 设计模式 public

简述

  • 类型:结构型
  • 目的:通过抽离出多个维度相互组合(聚合)来代替继承,简化系统。

话不多说,看个优化案例。

优化案例

现有系统中,对于画面窗口的边框有一套样式来控制是否有圆角。因为新的需求,需要增加两套样式,一套控制边框线条的颜色(红、黄、蓝),一套控制边框有无阴影。我们来看看几种实现方式。

最初版v0

我们看看用继承或实现的方式,会是什么样子。

interface Style {
    void style();
}
class Radius implements style {
    public void style() {
        radius();
    }
    protected void radius() {
        System.out.println("有边框圆角");
    }
}
class RadiusRed extends Radius {
    public void style() {
        super.style();
        this.red();
    }
    protected void red() {
        System.out.println("红色边框");
    }
}
class RadiusBlue extends Radius {
    public void style() {
        super.style();
        this.blue();
    }
    protected void blue() {
        System.out.println("蓝色边框");
    }
}
class RadiusYellow extends Radius {
    public void style() {
        super.style();
        this.yellow();
    }
    protected void yellow() {
        System.out.println("黄色边框");
    }
}
class RadiusRedShadow extends RadiusRed {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("有边框阴影");
    }
}
class RadiusBlueShadow extends RadiusBlue {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("有边框阴影");
    }
}
class RadiusYellowShadow extends RadiusYellow {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("有边框阴影");
    }
}
class RadiusRedNotShadow extends RadiusRed {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("无边框阴影");
    }
}
class RadiusBlueNotShadow extends RadiusBlue {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("无边框阴影");
    }
}
class RadiusYellowNotShadow extends RadiusYellow {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("无边框阴影");
    }
}
class NotRadius implements style {
    public void style() {
        radius();
    }
    protected void radius() {
        System.out.println("无边框圆角");
    }
}
class NotRadiusRed extends NotRadius {
    public void style() {
        super.style();
        this.red();
    }
    protected void red() {
        System.out.println("红色边框");
    }
}
class NotRadiusBlue extends NotRadius {
    public void style() {
        super.style();
        this.blue();
    }
    protected void blue() {
        System.out.println("蓝色边框");
    }
}
class NotRadiusYellow extends NotRadius {
    public void style() {
        super.style();
        this.yellow();
    }
    protected void yellow() {
        System.out.println("黄色边框");
    }
}
class NotRadiusRedShadow extends NotRadiusRed {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("边框阴影");
    }
}
class NotRadiusBlueShadow extends NotRadiusBlue {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("边框阴影");
    }
}
class NotRadiusYellowShadow extends NotRadiusYellow {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("边框阴影");
    }
}
class NotRadiusRedNotShadow extends NotRadiusRed {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("无边框阴影");
    }
}
class NotRadiusBlueNotShadow extends NotRadiusBlue {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("无边框阴影");
    }
}
class NotRadiusYellowNotShadow extends NotRadiusYellow {
    public void style() {
        super.style();
        this.shadow();
    }
    protected void shadow() {
        System.out.println("无边框阴影");
    }
}

可以看出,使用实现或者继承的方式来构件模块所需的类的数量及其的庞大(21个)。写吐了,太多太繁琐了。
再看看客户端的使用方法。

class Client {
    public static void main(String[] args) {
        Style style = new NotRadiusYellowNotShadow();
        style.style();
    }
}

客户端的使用还是比较简单的,但这并不能掩盖类的数量过多的问题。

那么除了这种方法,我们还有什么别的更好的办法可以实现吗?当然有了。

修改版v1

引入桥接模式,优化多维度继承问题。
首先,我们得分析这个模块。模块中有三种不同的维度(Radius,Color,Shadow),都是用来拓展Style的。将三个维度都抽象成接口,并且将Style定义为桥接类。我们看看新的代码。

interface Radius {
    void radius();
}
interface Color {
    void color();
}
interface Shadow {
    void shadow();
}
class HasRadius implements Radius {
    public void radius() {
        System.out.println("有边框圆角");
    }
}
class HasNotRadius implements Radius {
    public void radius() {
        System.out.println("无边框圆角");
    }
}
class Red implements Color {
    public void color() {
        System.out.println("红色边框");
    }
}
class Yellow implements Color {
    public void color() {
        System.out.println("黄色边框");
    }
}
class Blue implements Color {
    public void color() {
        System.out.println("蓝色边框");
    }
}
class HasShadow implements Shadow {
    public void shadow() {
        System.out.println("有边框阴影");
    }
}
class HasNotShadow implements Shadow {
    public void shadow() {
        System.out.println("无边框阴影");
    }
}
class Style {
    private Radius radius;
    private Color color;
    private Shadow shadow;
    public Style(Radius radius, Color color, Shadow shadow) {
        this.radius = radius;
        this.color = color;
        this.shadow = shadow;
    }
    public void init() {
        radius.radius();
        color.color();
        shadow.shadow();
    }
}

类的数量急剧减少,而且如果三个维度中有新的Style增加,也只需要在对应的维度增加新的实现类即可。即便增加新的维度,也只需要对应增加一套接口和实现类。最多在桥接类Style中增加持有的接口对象即可(虽然不符合开闭原则)。

我们再来看看客户端的使用方法。

class Client {
    public static void main(String[] args) {
        Style style = new Style(new HasRadius(), new Red(), new HasShadow());
        style.init();
    }
}

Style持有RadiusColorShadow,并且根据构造时传入的具体实现动态的更改持有的具体实现。易用性上也有着提升。

总结

优点

  1. 通过聚合或组合替代传统的继承方案。
  2. 提高了系统的可拓展性,每个维度增加新的是实现或者增加新的维度,对原有系统无影响。

缺点

  1. 增加系统的理解和设计难度,需要面向抽象编程。
  2. 需要预先确定正确的维度。看问题的角度不同得到的结果也不同,这个维度也是一样的,作为乙方想到的维度很有可能不是甲方预想的维度,所以这个维度的确认竟可能在功能实现前找客户确认完成之后决定。

适用场景

  1. 可以抽象出多个维度的功能组合的类设计的场景。

标签:style,桥接,void,class,---,println,shadow,设计模式,public
From: https://www.cnblogs.com/buzuweiqi/p/16726589.html

相关文章

  • F-02 BAPI
    *-----------BAPI参数定义DATA:ls_documentheaderTYPEbapiache09,lt_accountglTYPESTANDARDTABLEOFbapiacgl09,"总账lt_acc......
  • 经典重塑-yolov3的正负样本选择和损失函数的故事
    先讲一下正负样本选择,因为必须要先选择正负样本才能计算损失,毕竟坐标误差,iou误差和分类误差都是和正样本相关的。 然后再来讲一下损失函数的计算方式  我个人理......
  • sql注入 sql-labs过关实战学习
      一、SQL注入原理SQL注入就是把SQL命令插入到Web表单然后提交到所在页面请求(查询字符串),从而达到欺骗服务器执行恶意的SQL命令。(页面请求包括get、post等)它是利用现在......
  • 关于 find 指令的 +n、-n、n
    描述find指令查找文件时可以通过时间来锁定或缩小搜查范围。其中需要利用到文件的三个时间?:AccessTime(atime)、ModifyTime(mtime)和ChangeTime(ctime)。通常会指定在at......
  • LeetCode - 数组的改变和移动
    1.数组的改变和移动总结1.1数组的改变数组在内存中是一块连续的内存空间,我们可以直接通过下标进行访问,并进行修改。在Java中,对于List类型来说,我们可以通过set(idx,el......
  • 【微服务】- 服务调用 - OpenFeign
    服务调用-OpenFeign......
  • 2022-2023-1 20221413《计算机基础与程序设计》第四周学习总结
    ##作业信息|这个作业属于哪个课程|[2022-2023-1-计算机基础与程序设计](https://edu.cnblogs.com/campus/besti/2022-2023-1-CFAP)||这个作业要求在哪里|[2022-2023-1......
  • vue3 基础-Mixin
    本篇开始来学习一波vue中的一些复用性代码的基础操作,首先来介绍关于代码"混入"mixin的写法.直观理解这个mixin就是一个js对象去"混入"vue的组件呀,插件呀......
  • Python4-eg
    实例01importdatetime                        #导入日期时间类#定义一个列表mot=["今天星期一:\n坚持下去不是因为我很坚强,而是因为我别无......
  • 2022-2023-1 20221421 《计算机基础与程序设计》第四周学习总结
    作业信息班级链接:https://edu.cnblogs.com/campus/besti/2022-2023-1-CFAP作业要求:https://www.cnblogs.com/rocedu/p/9577842.html#WEEK04作业目标:门电路组合电路,逻辑电......