精华内容
下载资源
问答
  • 2022-03-27 00:33:01

    装饰器模式是什么

    装饰器模式是指给一个类增强一些方法,对其做一些包装,但是不会影响改变原本类。

    解决了什么问题:

    假设有一个炸鸡接口,定义了一个制作炸鸡的方法,麦当劳和肯德基和德克士对其的制作炸鸡方法做了重写,每个厂商肯定都有自己的实现。现在假设国家规定当制作完炸鸡需要对成品做一个检查。此时我们有2个解决方案,就是直接去每个厂家制作炸鸡的方法的最后一行加上检查的逻辑,这样太过于复杂,要不就是定义N个(看有多少个厂家)子类去继承原有厂家,然后重写制作炸鸡方法,先super调用父类的实现,再自己写检查的逻辑。这样也会特别的复杂,特多的冗余代码。

    所以就可以定义一个炸鸡接口的装饰类,内部维护一个炸鸡类,然后也是重写制作炸鸡方法,然后装饰类用内部维护的被装饰炸鸡类,调用制作炸鸡方法,然后把增强的逻辑加在方法后面,就可以完美的避免N个子类。

    装饰器模式的案例

    创建一个炸鸡接口

    /**
     * @Author liha
     * @Date 2022-03-27 19:20
     * 李哈YYDS
     */
    public interface FriedChicken {
    
        void makeFriedChicken();
    
    }

    KFC的继承炸鸡接口,重写制作炸鸡方法

    public class KFC implements FriedChicken{
    
        @Override
        public void makeFriedChicken() {
            System.out.println("肯德基制作了一份炸鸡");
        }
    }

    麦当劳的继承炸鸡接口,重写制作炸鸡方法

    public class McDonald implements FriedChicken{
    
        @Override
        public void makeFriedChicken() {
            System.out.println("麦当劳制作了一份炸鸡");
        }
    }

    然后定义一个炸鸡接口的装饰器类,对制作炸鸡方法进行一个加强!

    /**
     * @Author liha
     * @Date 2022-03-27 19:23
     * 李哈YYDS
     */
    public class FriedChickenDecorator implements FriedChicken{
    
        // 内部维护一个炸鸡类
        private FriedChicken friedChicken;
        
        // 通过构造方法把需要装饰的炸鸡类传进来
        public FriedChickenDecorator(FriedChicken friedChicken) {
            this.friedChicken = friedChicken;
        }
    
        // 增强方法
        @Override
        public void makeFriedChicken() {
    
            friedChicken.makeFriedChicken();
            System.out.println("检查炸鸡是否存在问题");
        }
    }

    测试类如下:

    /**
     * @Author liha
     * @Date 2022-03-27 19:24
     * 李哈YYDS
     */
    public class Test {
    
        public static void main(String[] args) {
    
            FriedChicken kfc = new KFC();
            System.out.println("没增强前:");
            kfc.makeFriedChicken();
            System.out.println("==================");
    
            FriedChicken mcDonald = new McDonald();
            System.out.println("没增强前:");
            mcDonald.makeFriedChicken();
            System.out.println("==================");
            
            // 把需要增强的类通过构造方法传进去
            FriedChicken kfcDecorator = new FriedChickenDecorator(kfc);
            System.out.println("增强后:");
            kfcDecorator.makeFriedChicken();
            System.out.println("==================");
            
            // 把需要增强的类通过构造方法传进去
            FriedChicken mcDonaldDecorator = new FriedChickenDecorator(mcDonald);
            System.out.println("增强后:");
            mcDonaldDecorator.makeFriedChicken();
            
        }
    }

     

    总结

    很简单的一句总结,就是套了一层,就可以为所欲为(手动滑稽)!

    优点:装饰类和被装饰类都互不受影响,不会改变原有逻辑,并且使用装饰器模式可以动态扩展功能。

    缺点:如果装饰类还是一个接口,那么就可能存在多层装饰,维护起来还是比较麻烦。

    与代理模式的区别:确实装饰器模式看起来跟代理模式特别的相似,但是对于代理模式来说可以作出一些操作改变原有代码,也就是说带有侵入性。而装饰器的定义是不能改变原有方法,只能对原有方法作出增强。

    更多相关内容
  • 主要为大家详细介绍了java实现装饰器模式Decorator Pattern,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 什么是装饰器模式 作为一种结构型模式, 装饰器(Decorator)模式就是对一个已有结构增加”装饰”. 适配器模式, 是为现在有结构增加的是一个适配器类,.将一个类的接口,转换成客户期望的另外一个接口.适配器让原本接口...
  • 主要为大家详细介绍了java设计模式之装饰器模式Decorator,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 装饰器模式

    千次阅读 2020-12-12 21:08:13
    所有这些都可以釆用装饰模式来实现。 一、装饰模式 1、装饰模式的定义 装饰模式(Decorator Pattern)的定义: 指在不改变现有对象结构的情况下,动态地给该对象增加一些职责(即增加其额外功能)的模式,它...

    在软件开发过程中,有时想用一些现存的组件。这些组件可能只是完成了一些核心功能。但在不改变其结构的情况下,可以动态地扩展其功能。所有这些都可以釆用装饰模式来实现。

    一、装饰器模式

    1、装饰器模式的定义

    装饰器模式(Decorator Pattern),又叫作包装器模式(Wrapper Pattern):

    指在不改变原有对象结构的基础情况下,动态地给该对象增加一些额外功能的职责。装饰器模式相比生成子类更加灵活。它属于对象结构型模式。

    装饰模式和代理模式的功能是雷同的,两者区别是:

    • 装饰器模式强调自身功能的扩展,是代理模式的一个特殊应用。
    • 代理模式强调对代理过程的控制。

    2、装饰器模式的结构

    通常情况下,扩展一个类的功能会使用继承方式来实现。但继承具有静态特征,耦合度高,并且随着扩展功能的增多,子类会很膨胀。
    如果使用组合关系来创建一个包装对象(即装饰对象)来包裹真实对象,并在保持真实对象的类结构不变的前提下,为其提供额外的功能,这就是装饰模式的目标。

    下面来分析其基本结构和实现方法。

    (1)模式的结构

    装饰模式主要包含四个角色。

    • 抽象构件(Component): 可以是一个接口或者抽象类,充当被装饰类的原始对象,规定了被装饰类的行为。
    • 具体构件(ConcreteComponent): 实现/继承 Component的一个具体对象,即被装饰对象。通过装饰角色为其添加一些职责。
    • 抽象装饰器(Decorator): 实现/继承 Component。通用的 ConcreteComponent的装饰列,其内部必然有一个属性指向 Component,主要是可以通过其子类扩展具体组件的功能。
    • 具体装饰器(ConcreteDecorator): Decorator的具体实现类,并给具体构件对象添加附加的责任,一般为其特有的功能。

    装饰器模式j角色分配符合设计模式的里氏替换原则、依赖倒置原则,从而使得其具备很强的扩展性,最终满足开闭原则。

    (2)结构图如下:(图来自网络)
    在这里插入图片描述

    3、优缺点

    主要优点:

    • 装饰器是继承的有力补充,比继承灵活,在不改变原有对象的情况下,动态的给一个对象扩展功能,即插即用
    • 通过使用不用装饰类及这些装饰类的排列组合,可以实现不同效果
    • 装饰器模式完全遵守开闭原则

    主要缺点:

    • 会出现更多的代码、更多的类,增加程序的复杂性。

    4、使用场景

    • 当需要给一个现有类添加附加职责,而又不能采用生成子类的方法进行扩充时。
    • 当对象的功能要求可以动态地添加,也可以再动态地被撤销时。
    • 当需要通过对现有的一组基本功能进行排列组合而产生非常多的功能时,采用继承关系很难实现,而采用装饰模式却很好实现。

    在框架源码中使用也很广泛,比如:

    • JDK中的处理流 IO中包装流类等
    • Spring 中处理事务缓存的 TransactionAwareCacheDecorator类
    • Mybatis 中处理缓存设计的 Cache类等

    二、模式的通用实现

    代码如下:

    public class DecoratorPattern {
        public static void main(String[] args) {
            Component p = new ConcreteComponent();
            p.operation();
            System.out.println("---------------装饰之后------------------");
            Component d = new ConcreteDecorator(p);
            d.operation();
        }
    }
    
    //抽象构件
    interface Component {
        public void operation();
    }
    
    //具体构件
    class ConcreteComponent implements Component {
        public ConcreteComponent() {
            System.out.println("创建具体构件角色");
        }
    
        // 相应的功能处理
        @Override
        public void operation() {
            System.out.println("调用具体构件角色的方法operation()");
        }
    }
    
    //抽象装饰器
    class Decorator implements Component {
        // 持有的组件对象
        private Component component;
    
        public Decorator(Component component) {
            this.component = component;
        }
    
        @Override
        public void operation() {
            // 处理前后可以加一些附加功能
            component.operation();
        }
    }
    
    //具体装饰器
    class ConcreteDecorator extends Decorator {
        public ConcreteDecorator(Component component) {
            super(component);
        }
    
        @Override
        public void operation() {
            // 在处理父类的方法时,可以在处理前后可以加一些附加功能
            // 如果不调用父类的方法,表示完全改写方法,实现新功能
            super.operation();
            addedFunction();
        }
    
        public void addedFunction() {
            System.out.println("为具体构件角色增加额外的功能addedFunction()");
        }
    }
    

    三、模式的应用实例

    用一个卖煎饼果子的例子来说明。

    • 原味版:煎饼果子,总价格:5
    • 豪华版:辅料可自由搭配

    1、抽象构件(Component)

    public abstract class Battercake {
    
        protected abstract  String  getMessage();
    
        protected abstract int getPrice();
    }
    

    2、具体构件(ConcreteComponent)

    public class BaseBattercake extends Battercake{
    
        @Override
        protected String getMessage() {
            return "煎饼果子";
        }
    
        @Override
        protected int getPrice() {
            return 5;
        }
    }
    

    3、抽象装饰器(Decorator)

    public abstract class BattercakeDecorator extends Battercake{
        // 静态代理,委托
        private Battercake battercake;
    
        public BattercakeDecorator(Battercake battercake) {
            this.battercake = battercake;
        }
    
        @Override
        protected String getMessage() {
            return this.battercake.getMessage();
        }
    
        @Override
        protected int getPrice() {
            return this.battercake.getPrice();
        }
    
        // 可以加额外功能方法
        protected abstract void addedFunction();
    }
    

    4、具体装饰器(ConcreteDecorator)
    这里给定三种辅料可供选择

    • 鸡蛋
    public class EggDecorator extends BattercakeDecorator {
    
        public EggDecorator(Battercake battercake) {
            super(battercake);
        }
    
        @Override
        protected String getMessage() {
            return super.getMessage() + " + 1个鸡蛋";
        }
    
        @Override
        protected int getPrice() {
            return super.getPrice() + 2;
        }
    
        @Override
        protected void addedFunction() {
    
        }
    
        // 可以加其特有的功能方法
    }
    
    • 香肠
    public class SausageDecorator extends BattercakeDecorator{
    
        public SausageDecorator(Battercake battercake) {
            super(battercake);
        }
    
        @Override
        protected String getMessage() {
            return super.getMessage() + " + 一个香肠";
        }
    
        @Override
        protected int getPrice() {
            return super.getPrice() + 4;
        }
    
        @Override
        protected void addedFunction() {
    
        }
        // 可以加其特有的功能方法
    }
    
    • 另类
    public class OtherDecorator extends BattercakeDecorator{
        public OtherDecorator(Battercake battercake) {
            super(battercake);
        }
    
        @Override
        protected String getMessage() {
            return message();
        }
    
        @Override
        protected int getPrice() {
            return price();
        }
    
        @Override
        protected void addedFunction() {
    
        }
    
        // 可以加其特有的功能方法
        private String message(){
            return "老板,啥也不要,来根大葱";
        }
        private int price(){
            return 5;
        }
    }
    

    5、测试

    public class Test {
        public static void main(String[] args) {
            System.out.println("===来一个基础版煎饼果子===");
            Battercake battercake = new BaseBattercake();
            System.out.println(battercake.getMessage() + ",总价格:" + battercake.getPrice() + "元。");
    
            System.out.println("===来一个套餐A煎饼果子===");
            battercake = new EggDecorator(battercake);
            System.out.println(battercake.getMessage() + ",总价格:" + battercake.getPrice() + "元。");
    
            System.out.println("===来一个套餐A+B煎饼果子===");
            battercake = new SausageDecorator(battercake);
            System.out.println(battercake.getMessage() + ",总价格:" + battercake.getPrice() + "元。");
    
    
            System.out.println("===屌丝买煎饼果子===");
            Battercake battercake2 = new BaseBattercake();
            battercake2 = new OtherDecorator(battercake2);
            System.out.println(battercake2.getMessage() + ",总价格:" + battercake2.getPrice() + "元。");
        }
    }
    

    在这里插入图片描述

    四、装饰模式的扩展

    装饰模式所包含的 4 个角色不是任何时候都要存在的,在有些应用环境下模式是可以简化的,有时候抽象装饰器是可有可无的,如以下两种情况。(图来自网络)

    1、只有一个具体装饰器,这样就不需要抽象装饰器,其结构图如下:
    在这里插入图片描述
    2、只有一个具体构件,这样就不需要抽象构件,抽象装饰者可以直接继承具体构件,其结构图如下:
    在这里插入图片描述
    3、只有一个具体构件和一个具体装饰者,这样抽象角色都不需要了,具体装饰者直接继承集体构件就可以了
    在这里插入图片描述

    参考文章:

    —— Stay Hungry. Stay Foolish. 求知若饥,虚心若愚。

    展开全文
  • 主要介绍了PHP简单装饰器模式实现与用法,结合具体实例形式分析了php装饰器模式的原理、实现与使用方法,需要的朋友可以参考下
  • 主要介绍了C#装饰器模式(Decorator Pattern),以一个完整实例形式讲述了C#装饰器模式的实现过程,有助于深入理解C#程序设计思想,需要的朋友可以参考下
  • 主要介绍了设计模式中的装饰器模式在iOS应用开发中的实现,包括对分类和委托的深入讲解,需要的朋友可以参考下
  • 装饰模式 PPT 前端 javascript 讲解了装饰模式在前端的运用,举例说明,ppt内的代码连起来可执行
  • 装饰器模式的简单demo

    2020-06-27 00:16:20
    简单了说明,并用代码的方式解释了什么是装饰器模式,方便想要学习设计模式的童靴可以更好的学习和掌握设计模式,是自己的代码变得更高效和优雅
  • 漫谈 如果作为一个Python入门,不了解Python装饰器也没什么,但是如果作为一个中级Python开发人员,如果再不对python装饰器...在设计模式学习—-装饰器模式,我摘取了下面一段使用装饰器模式的代码 public class De
  • 装饰器模式又叫装饰者模式。装饰模式是在不必改变原类文件和使用继承的情况下,动态地扩展一个对象的功能。它是通过创建一个包装对象,也就是装饰来包裹真实的对象。 UML类图: 角色: 组件对象的接口:可以给这些...
  • 本工程是使用demo构建装饰器,以及装饰器的使用案例。 从最简单的装饰器到带参数的,带任意参数的,到类装饰器等。代码案例比较全。可作为学习参考与交流。
  • 2 装饰器模式-MOOC课程内容.pdf
  • c++设计模式-结构型模式-装饰器模式;QT工程;c++简单源码; 装饰器(Decorator)模式的定义:指在不改变现有对象结构的情况下,动态地给该对象增加一些职责(即增加其额外功能)的模式,它属于对象结构型模式。
  • 设计模式-装饰器模式

    2016-11-30 21:29:12
    ios平台中通过最简单的代码讲解装饰器模式,可在博客http://blog.sina.com.cn/s/blog_161d504630102wxis.html中查看简单解释
  • 如果已有对象的部分内容或功能性发生改变,但是不需要修改原始对象的结构或不使用继承,动态的扩展一个对象的功能,则应该使用装饰器模式。 简单点说:就是我们不应该去修改已有的类,而是通过创建另外一个装饰器类...
  • 什么是装饰器模式 装饰器模式从字面意思来说就是对某一个事物进行装饰的一种模式。从代码层面而言,是对类的一个扩展或者是修饰,从传统方法而言,我们可以使用继承来对某一个类进行扩展,但是往往会导致会出现非常...

    什么是装饰器模式

    装饰器模式从字面意思来说就是对某一个事物进行装饰的一种模式。从代码层面而言,是对类的一个扩展或者是修饰,从传统方法而言,我们可以使用继承来对某一个类进行扩展,但是往往会导致会出现非常多的子类,如果我们要想避免这种情况,那么我们就可以使用设计模式中的——装饰器模式。

    装饰器模式的优缺点

    装饰器模式是在不改变现有对象结构的情况下,动态地给该对象增加一些职责,即增加其额外功能。

    但是如果对于一个类型装饰的类的扩展功能太多,那么将会导致有很多的小类,我们在选择使用装饰器设计模式的时候要根据实际情况进行选择。

    案例

    定义一个Person接口,定义两个方法 getRole 和 getAge,创建三个实体类(Father、Mother、Son)实现(implements)Person 接口。定义一个装饰类 继承(extends)Person,并设置私有的成员变量Person,创建一个特定的装饰修饰类(PersonMaleDecorator)设置成员为男性。

    在这里插入图片描述
    Person

    public class PersonDecorator implements Person {
    
        private Person person;
    
        public PersonDecorator(Person person) {
            this.person = person;
        }
    
        @Override
        public void getRole() {
    
            person.getRole();
        }
    
        @Override
        public void getAge() {
    
            person.getAge();
        }
    }
    

    Father

    public class Father implements Person {
        @Override
        public void getRole() {
            System.out.println("role : father");
        }
    
        @Override
        public void getAge() {
            System.out.println("father age : 38 years");
        }
    }
    

    Mother

    public class Mother implements Person {
        @Override
        public void getRole() {
            System.out.println("role : mother");
        }
    
        @Override
        public void getAge() {
            System.out.println("mather age : 35 years");
        }
    }
    

    Son

    public class Son implements  Person {
        @Override
        public void getRole() {
            System.out.println("role : son");
        }
    
        @Override
        public void getAge() {
            System.out.println("son age : 7 years");
        }
    }
    

    PersonDecorator

    public class PersonDecorator implements Person {
    
        private Person person;
    
        public PersonDecorator(Person person) {
            this.person = person;
        }
    
        @Override
        public void getRole() {
    
            person.getRole();
        }
    
        @Override
        public void getAge() {
    
            person.getAge();
        }
    }
    

    PersonMaleDecorator

    public class PersonMaleDecorator extends PersonDecorator {
        public PersonMaleDecorator(Person person) {
            super(person);
        }
    
        @Override
        public void getRole() {
            super.getRole();
            this.setGender();
        }
    
        @Override
        public void getAge() {
            super.getAge();
        }
    
        private void setGender(){
            System.out.println("Ta is male");
        }
    }
    

    main

    public class DecoratorDemo {
        public static void main(String[] args) {
            Mother mother = new Mother();
    
            PersonMaleDecorator father = new PersonMaleDecorator(new Father());
            PersonMaleDecorator son = new PersonMaleDecorator(new Son());
    
            mother.getRole();
            mother.getAge();
            System.out.println("-------------------------");
    
            father.getRole();
            father.getAge();
            System.out.println("-------------------------");
    
            son.getRole();
            son.getAge();
        }
    }
    

    结果:

    role : mother
    mather age : 35 years
    -------------------------
    role : father
    Ta is male
    father age : 38 years
    -------------------------
    role : son
    Ta is male
    son age : 7 years
    
    展开全文
  • Java装饰器模式详解

    2021-01-24 22:17:10
    装饰器模式也叫做包装器模式,属于结构性设计模式一种,装饰器设计模式在实际的生活中也有很多体现,举例来说,某手机厂商发布了XXX标准版手机,为了吸引用户眼球,提升销量,还特别有纪念碑,青春版,至尊版等 ...

    前言

    装饰器模式也叫做包装器模式,属于结构性设计模式一种,装饰器设计模式在实际的生活中也有很多体现,举例来说,某手机厂商发布了XXX标准版手机,为了吸引用户眼球,提升销量,还特别有纪念碑,青春版,至尊版等

    我们可以这么设想,不管是哪个版本的手机,其基本的功能是不变的,电话、短信、拍照等这些基础的功能在各个版本都能找到

    但是不同的版本,基于某个基础的版本,根据标价的不同添加了更多定制化或个性化的功能,相当于是说丰富了标准版的功能

    • 装饰器模式作为现有类的一个包装,允许向现有的对象添加注入新的功能,同时还不改变原有的结构
    • 给基础对象添加功能,一般有2种方式,继承或关联组合,将一个类的对象嵌入到另一个对象中,由另一个对象来决定是否调用嵌入对象的行为来增强功能,这个就是装饰器模式,相比继承更加灵活

    在JDK源码里面使用最多的就是IO流,大量使用到了装饰器设计模式

    装饰器设计模式的简易结构图如下所示:
    在这里插入图片描述

    对上图中各个组件的作用做简单的解释:

    • 角色:(装饰者和被装饰者具有相同的超类(可以理解为接口))
    • 抽象组件:定义装饰器方法的规范,比如手机,仅定义了打电话,发短信功能
    • 被装饰者:Component的具体实现,也就是我们即将要装饰的具体对象,实现了接口中的方法,比如打电话,发短信
    • 装饰者组件:定义了具体装饰者的行为规范,和Component角色具有相同的接口,并持有组件(Component)对象实例的引用,即其他版本的手机都有打电话和短信的功能
    • 具体装饰物:负责给基础组件添加新的功能,比如在电话和短信基础上定制了视频通话功能

    代码演示

    定义基本的接口

    public interface Phone {
        String desc();
        int getPrice();
    }
    

    具体的被装饰类的实现,以手机为例,这里提供标准版手机,普通版和高配版

    StandardPhone

    public class StandardPhone implements Phone{
    
        private String desc = "标准版手机";
    
        @Override
        public String desc() {
            return desc;
        }
    
        @Override
        public int getPrice() {
            return 1000;
        }
    
    }
    

    MiddlePhone

    public class MiddlePhone implements Phone{
    
        private String desc = "普通版手机";
    
        @Override
        public String desc() {
            return desc;
        }
    
        @Override
        public int getPrice() {
            return 1500;
        }
    }
    

    HighLevelPhone

    public class HighLevelPhone implements Phone{
    
        private String desc = "尊贵版手机";
    
        @Override
        public String desc() {
            return desc;
        }
    
        @Override
        public int getPrice() {
            return 2500;
        }
    }
    

    手机装饰器:

    装饰器在这里起到一个中间层作用,方便后面的扩展,具体的装饰实现延迟到子类中

    public class PhoneDecorator implements Phone {
    
        private String desc = "这是装饰器";
    
        @Override
        public String desc() {
            return desc;
        }
    
        @Override
        public int getPrice() {
            return 0;
        }
    
    }
    

    添加了视频通话的装饰器类

    public class VideoDecorator extends PhoneDecorator{
    
        private String desc = "增加一个视频通话功能";
    
        private int videoPrice = 500;
    
        private Phone phone;
    
        public VideoDecorator(Phone phone){
            this.phone=phone;
        }
    
        @Override
        public String desc() {
            return phone.desc() + "," + desc;
        }
    
        @Override
        public int getPrice() {
            return phone.getPrice() + videoPrice;
        }
    
    }
    

    增加了wifi充电功能的装饰器类

    public class WifiChargeDecorator extends PhoneDecorator {
    
        private String desc = "增加一个wifi充电功能";
    
        private int wifiAddProce = 800;
    
        private Phone phone;
    
        public WifiChargeDecorator(Phone phone){
            this.phone=phone;
        }
    
        @Override
        public String desc() {
            return phone.desc() + "," + desc;
        }
    
        @Override
        public int getPrice() {
            return phone.getPrice() + wifiAddProce;
        }
    }
    

    新增的手机的附加功能可以通过多个装饰类实现,方便客户端调用时自由选择,如果有更多的装饰类,可以按照上面的方式继续添加

    下面来简单测试下,

    1、获取一个普通版手机

    public static void main(String[] args) {
            /**
             * 基础测试
             */
            Phone phone = new MiddlePhone();
            System.out.println(phone.desc() + " --- " + phone.getPrice());
        }
    

    在这里插入图片描述

    2、在普通版手机基础上增加视频通话功能

    public static void main(String[] args) {
            /**
             * 基础测试
             */
            Phone phone = new MiddlePhone();
            System.out.println(phone.desc() + " --- " + phone.getPrice());
            System.out.println();
            /**
             * 增加视频通话功能
             */
            phone = new VideoDecorator(phone);
            System.out.println(phone.desc() + " --- " + phone.getPrice());
        }
    

    在这里插入图片描述
    3、在普通版手机基础上继续增加wifi充电功能

    public static void main(String[] args) {
            /**
             * 基础测试
             */
            Phone phone = new MiddlePhone();
            System.out.println(phone.desc() + " --- " + phone.getPrice());
            System.out.println();
            /**
             * 增加视频通话功能
             */
            phone = new VideoDecorator(phone);
            System.out.println(phone.desc() + " --- " + phone.getPrice());
            System.out.println();
    
            /**
             * 增加wifi充电功能
             */
            phone = new WifiChargeDecorator(phone);
            System.out.println(phone.desc() + " --- " + phone.getPrice());
        }
    

    在这里插入图片描述

    通过上面的代码演示,可以清楚的看到,使用装饰器模式可以很灵活的对既有的基础组件对象持有的功能进行补充和扩展,可以根据自身的业务诉求进行自由搭配

    装饰器设计模式,优点:

    • 装饰模式与继承关系的目的都是要扩展原有对象的功能,但是装饰器模式比继承增加了更多的灵活性
    • 使用不同的具体装饰类以及这些装饰类的排列组合,可以创造出更多的不同行为的组合,原有的代码无需改变,符合“开闭”原则

    缺点:

    • 装饰器模式添加了许多子类,过多使用会使程序变得很复杂
    • 增加了系统的复杂程度,加大了使用者的学习成本和理解难度

    在JDK源码中的应用

    IO流的读取与写入在JDK源码中大量使用到了装饰器模式,简单来说,按照装饰器模式下其组件的划分,可以总结如下:

    • 抽象组件:(Component):Inputstream,定义了装饰方法的规范
    • 被装饰者:(ConcreteComponent):FileInputStream,ByteArrayInputStream,Component的具体实现,也就是要装饰的具体对象
    • 装饰者组件:(Decorator):FileInputStream,定义装饰者行为规范,和Component具有相同接口,持有对象组件(Component)的实例引用
    • 具体装饰物:(ConcreteDecorator)BufferedInputStream,DataInputStream,负责给构件对象添加额外的功能

    下面来看一下DataInputStream和DataOutputStream的类结构图,可以发现它们的顶层实现了InputStream或者OutputStream
    在这里插入图片描述

    在这里插入图片描述

    一个具体的实现案例

    public static void main(String[] args) throws IOException {
            DataInputStream in = new DataInputStream(new FileInputStream("D:\\test.txt"));
            DataOutputStream out = new DataOutputStream(new FileOutputStream("D:\\test1.txt"));
            BufferedReader d = new BufferedReader(new InputStreamReader(in));
            String count;
            while ((count = d.readLine()) != null) {
                String u = count.toUpperCase();
                System.out.println(u);
                out.writeBytes(u + "  ,");
            }
            d.close();
            out.close();
        }
    

    本篇通过实例演示并说明了装饰器设计模式的使用,可以结合自身的业务使用装饰器模式对代码进行优化和改进,本篇到此结束,最后感谢观看!

    展开全文
  • 装饰模式可以在不改变一个对象本身功能的基础上增强或增加某些功能,举个例子,就相当于武侠小说里的内功,同样都是降龙十八掌,因为降龙十八掌属于外功,所以可能学了九阳真经的人和没有学九阳真经的人使用起来的...
  • 装饰器模式(Decorator Pattern)允许向一个现有的对象添加新的功能,同时又不改变其结构。这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。 这种模式创建了一个装饰类,用来包装原有的类,并在...
  • NULL 博文链接:https://alaric.iteye.com/blog/1911949
  • 本文实例讲述了Python装饰器模式定义与用法。分享给大家供大家参考,具体如下: 装饰器模式定义:动态地给一个对象添加一些额外的职责。 在Python中Decorator mode可以按照像其它编程语言如C++, Java等的样子来实现...
  • 设计模式之装饰器模式(C++实现)

    千次阅读 2020-12-31 23:00:10
    装饰器模式介绍,包括应用场景,优缺点,模式结构,类图 以及 C++代码示例
  • 本文实例讲述了PHP设计模式:装饰器模式Decorator。分享给大家供大家参考,具体如下: 1. 概述  若你从事过面向对象开发,实现给一个类或对象增加行为,使用继承机制,这是所有面向对象语言的一个基本特性。如果...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 110,198
精华内容 44,079
关键字:

装饰器模式