装饰者模式

最新推荐文章于 2023-07-16 10:42:52 发布
最新推荐文章于 2023-07-16 10:42:52 发布
阅读量326 收藏 1
点赞数 1
分类专栏： Head First设计模式 文章标签： 装饰者模式 装饰者模式示例 装饰者 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/justry_deng/article/details/103384886
版权

声明： 本文内容属于《Head First 设计模式》阅读笔记，文中涉及到的知识案例等直接或间接来源于该书。《Head First 设计模式》通过有趣的图表+文字的形式，让人自然学习设计模式，非常棒，推荐阅读。

装饰者模式概念：

        动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案。

要点说明：

序号说明
①装饰者与被装饰者需要具有同一个超类(即：这两者的某个祖先类要相同)。
②程序需要的也只是超类，而不具体到哪一个子类，这样一来该超类的任何子类都能被程序认可。
③装饰者中应持有被装饰者实例，这样一来，装饰者里面就能调用到被装饰者的相关方法，进而进行装饰。
④装饰者中持有被装饰者时，声明被装饰者的类型时应声明为超类的类型(而不声明为某个具体的被装饰者类)。这样一来，(因为装饰者、被装饰者都是这个超类的子类，所以)装饰者不仅可以装饰被装饰者，装饰者还可以装饰装饰者。
⑤装饰者应重写(所有装饰后)会受到影响的方法。
注：重写的方法来自超类。

图示(示例)说明：

在这里插入图片描述

案例(辅助理解)：

提示： 装饰者模式使用灵活，下面只是一个简单的例子，在不同的情境下，可能有不同的表现形式。

情景(需求)介绍：

       现有一家星巴兹咖啡馆，里面有各种咖啡(焦炒咖啡、低浓咖啡、浓缩咖啡、首选咖啡)以及各种调味料(牛奶、摩卡、豆浆、奶泡)。现在的需求是：客人在点咖啡时还可以点任意(任意种类、任意数量的)调料。

从装饰者模式出发：

  1. 各种咖啡，各种调料的共同超类，为饮料beverage。
  2. 各种咖啡为饮料的直接实现，为被装饰者。
  3. 各种调料是饮料的附加添加品，为装饰者。
  4. 可以将装饰者的共有逻辑进行抽取，抽取为一个抽象类。

于是得到以下UML类图：在这里插入图片描述提示：上图中没有显示方法项，装饰者应重写装饰后受影响的方法(重写的方法来自超类)。

上述装饰者模式示例中的几个核心类及代表类：

  • AbstractBeverage：抽象超类。

    import lombok.Getter;
import lombok.Setter;

/**
 * 饮料(的抽象定义)
 *
 * 注: 在java中的装饰者模式，超类既可采用【抽象类】，亦可采用【接口】。
 *     不过一般都采用 抽象类。
 *
 * @author JustryDeng
 * @date 2019/12/3 11:45
 */
public abstract class AbstractBeverage {

    /** 描述 */
    @Setter
    @Getter
    private String description;

    /**
     * 获取饮料的价格
     *
     * @return  饮料的价格
     */
    public abstract double cost();
}

    注：超类既可采用抽象类，亦可采用接口。不过一般都采用抽象类。

  • AbstractCondimentDecorator：装饰者抽象类。

    import com.szlaozicl.designpattern.decorator.AbstractBeverage;

/**
 * (装饰饮料的)调料装饰者(的抽象定义)
 *
 * @author JustryDeng
 * @date 2019/12/3 11:50
 */
@SuppressWarnings("all")
public abstract class AbstractCondimentDecorator extends AbstractBeverage {

    /** 被装饰者 */
    protected AbstractBeverage decoratedObj;

    /**
     * 构造器
     *
     * @param decoratedObj
     *            被装饰者
     * @date 2019/12/4 12:30
     */
    protected AbstractCondimentDecorator(AbstractBeverage decoratedObj) {
        this.decoratedObj = decoratedObj;
    }

    /**
     * 装饰者应重写 饮料的描述
     * 注: 之所以需要重写饮料的描述, 是因为原来的描述没有对调料的介绍。
     * 特别注意: 装饰者 应重写 装饰前后相关的方法。 如，这里的描述、价格。
     *
     * @return 饮料的描述
     */
    @Override
    public abstract String getDescription();
}

    注：对于所有装饰者共有的特征，可进行抽取，抽取为抽象类或非抽象类均可。

  • Espresso：被装饰者代表类。

    import com.szlaozicl.designpattern.decorator.AbstractBeverage;

/**
 * 具体饮料 - 浓缩咖啡
 *
 * @author JustryDeng
 * @date 2019/12/3 12:03
 */
public class Espresso extends AbstractBeverage {

    /** 无参构造 */
    public Espresso() {
        // 当前饮料的描述
        setDescription("浓缩咖啡Espresso");
    }

    @Override
    public double cost() {
        return 1.99;
    }
}

  • MilkCondimentDecorator：装饰者代表类。

    import com.szlaozicl.designpattern.decorator.AbstractBeverage;

/**
 * 具体的调料(装饰者) - 牛奶Milk
 *
 * @author JustryDeng
 * @date 2019/12/3 12:33
 */
public class MilkCondimentDecorator extends AbstractCondimentDecorator {

    /** 构造 */
    public MilkCondimentDecorator(AbstractBeverage decoratedObj) {
        super(decoratedObj);
    }

    @Override
    public String getDescription() {
        // 被装饰者 原来的description
        String oldDescription = decoratedObj.getDescription();
        // 对原来的description进行装饰
        return oldDescription + " + 牛奶Milk";
    }

    @Override
    public double cost() {
        // 被装饰者 原来的 价格
        double oldCost = decoratedObj.cost();
        // 对原来的价格进行装饰
        return oldCost + 0.1;
    }
}

测试一下：

  • 测试类：

    import com.szlaozicl.designpattern.decorator.beverage.DarkRoast;
import com.szlaozicl.designpattern.decorator.beverage.Decat;
import com.szlaozicl.designpattern.decorator.beverage.Espresso;
import com.szlaozicl.designpattern.decorator.decorator.MilkCondimentDecorator;
import com.szlaozicl.designpattern.decorator.decorator.MochaCondimentDecorator;
import com.szlaozicl.designpattern.decorator.decorator.SoyCondimentDecorator;
import com.szlaozicl.designpattern.decorator.decorator.WhipCondimentDecorator;

/**
 * 装饰者模式 --- 测试
 *
 * @author JustryDeng
 * @date 2019/12/3 12:54
 */
public class Test {

    /** 函数入口 */
    public static void main(String[] args) {
        System.out.println(" ------------- 测试一");
        testOne();

        System.out.println("\n ------------- 测试二");
        testTwo();

        System.out.println("\n ------------- 测试三");
        testThree();
    }

    /** 测试一 */
    private static void testOne() {
        AbstractBeverage beverage = new Espresso();
        System.err.println("装饰前:");
        System.out.println("描述:" + beverage.getDescription());
        System.out.println("价格:" + beverage.cost());

        // 给Espresso装饰 牛奶Milk
        beverage = new MilkCondimentDecorator(beverage);
        System.err.println("装饰后:");
        System.out.println("描述:" + beverage.getDescription());
        System.out.println("价格:" + beverage.cost());
    }

    /** 测试二 */
    private static void testTwo() {
        AbstractBeverage beverage = new DarkRoast();
        System.err.println("装饰前:");
        System.out.println("描述:" + beverage.getDescription());
        System.out.println("价格:" + beverage.cost());

        // 给DarkRoast装饰 牛奶Milk
        beverage = new MilkCondimentDecorator(beverage);
        /*
         * 继续装饰 豆浆Soy
         *
         * 注:虽然直接装饰的对象是MilkCondimentDecorator，但是由
         *    于MilkCondimentDecorator其实是对DarkRoast的装饰，
         *    所以实际上装饰的还是DarkRoast
         */
        beverage = new SoyCondimentDecorator(beverage);
        System.err.println("装饰后:");
        System.out.println("描述:" + beverage.getDescription());
        System.out.println("价格:" + beverage.cost());
    }

    /** 测试三 */
    private static void testThree() {
        AbstractBeverage beverage = new Decat();
        System.err.println("装饰前:");
        System.out.println("描述:" + beverage.getDescription());
        System.out.println("价格:" + beverage.cost());

        // 给DarkRoast装饰 奶泡Whip
        beverage = new WhipCondimentDecorator(beverage);
        // 继续装饰 摩卡Mocha
        beverage = new MochaCondimentDecorator(beverage);
        // 继续装饰 奶泡Whip
        beverage = new WhipCondimentDecorator(beverage);
        System.err.println("装饰后:");
        System.out.println("描述:" + beverage.getDescription());
        System.out.println("价格:" + beverage.cost());
    }
}

运行测试类main方法，控制台输出：
在这里插入图片描述

拓展 - 自定义InputStream子类的装饰者：

        java.io包下大量运用了装饰者模式(或在装饰者模式基础上进行了变形)，如InputStream、OutputStream、Reader、Writer等。

  • 以InputStream为例，其UML类图部分如图：
    在这里插入图片描述

  • 自定义一个大写转换为小写的装饰者，并编写测试类：

    import java.io.ByteArrayInputStream;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * 对java.io包下的I/O进行自定义装饰者 测试
 * <p>
 * 说明: java.io包下的I/O就大量用到了 装饰者模式，
 * 这里自己实现一个 InputStream的装饰者 以作练习。
 *
 * @author JustryDeng
 * @date 2019/12/3 12:54
 */
@SuppressWarnings("all")
public class IOTest {

    /** 函数入口 */
    public static void main(String[] args) throws IOException {
        InputStream in = new LowerCaseInputStream(new ByteArrayInputStream("ABCDEFG".getBytes()));
        int c;
        while ((c = in.read()) > 0) {
            // 输出结果为: abcdefg
            System.out.print((char) c);
        }
    }

}

/**
 * 自定义InputStream子类的装饰者
 *
 * @author JustryDeng
 * @date 2019/12/3 13:17
 */
@SuppressWarnings("all")
class LowerCaseInputStream extends FilterInputStream {

    public LowerCaseInputStream(InputStream in) {
        super(in);
    }

    /**
     * 从此输入流中读取下一个数据字节。返回一个 0 到 255 范围内的 int 字节值。
     * 如果因为已经到达流末尾而没有字节可用，则返回 -1。
     */
    @Override
    public int read() throws IOException {
        int c = super.read();
        if (c == -1) {
            return c;
        }
        return Character.toLowerCase((char) c);
    }


    /**
     * 从此输入流中将 len 个字节的数据读入到这个 给定的byte数组中。
     */
    @Override
    public int read(byte[] b, int offset, int len) throws IOException {
        int result = super.read(b, offset, len);
        // 注: len为允许一次读取的最大字节数， 而result为该次实际读取的字节数, 所以得以result为准
        // 注: 数据结果存储在b中，只需要将b里面的大写字母转换为小写即可
        for (int i = offset; i < offset + result; i++) {
            b[i] = (byte) Character.toLowerCase((char) b[i]);
        }
        return result;
    }
}

  • 控制台输出：
    在这里插入图片描述

拓展 - 一个不伦不类的cglib代理，实现装饰者模式：

提示： 同样的，使用jdk动态代理也能比较优雅的实现包装(P.S.代理模式不就是一种特殊的装饰者模式嘛)。

import com.szlaozicl.designpattern.author.JustryDeng;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;
import java.util.Objects;

/**
 * 以一个不伦不类的cglib代理实现包装
 *
 * @author {@link JustryDeng}
 * @since 2020/8/4 22:10:36
 */
@SuppressWarnings({"unchecked", "unused"})
public class MonsterProxyWrapper<T> implements MethodInterceptor {
    
    protected final T target;
    
    protected MonsterProxyWrapper(T target) {
        this.target = target;
    }
    
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        preHandle(proxy, method, args, methodProxy);
        Object result = method.invoke(target, args);
        result = postHandle(proxy, method, args, methodProxy, result);
        return result;
    }
    
    /**
     * 前处理
     *
     * @see this#intercept
     */
    protected void preHandle(Object proxy, Method method, Object[] args, MethodProxy methodProxy) {
        // [optional] sub-class ext
    }
    
    /**
     * 后处理
     *
     * @see this#intercept
     * @param result
     *            调用结果
     */
    protected Object postHandle(Object proxy, Method method, Object[] args, MethodProxy methodProxy, Object result) {
        // [optional] sub-class ext
        return result;
    }
    
    /**
     * 获取代理对象
     *
     * P.S. 内部会调用到被代理对象的无参构造
     */
    public T getProxyInstance() {
        Enhancer en = new Enhancer();
        en.setSuperclass(target.getClass());
        en.setCallback(this);
        return (T)en.create();
    }
    
    /**
     * 获取代理对象
     *
     * 提示: 这里en.create(argumentTypes, arguments)构造出来的代理类只是一个空壳子，所以只要能够造出来对象，
     *       argumentTypes和arguments随便传都可以
     */
    public T getProxyInstance(Class<Object>[] argumentTypes, Object[] arguments) {
        Objects.requireNonNull(argumentTypes, "argumentTypes cannot been null");
        Objects.requireNonNull(arguments, "arguments cannot been null");
        Enhancer en = new Enhancer();
        en.setSuperclass(target.getClass());
        en.setCallback(this);
        return (T)en.create(argumentTypes, arguments);
    }
}

提示：装饰者模式可结合工厂模式/建造者模式进行优化。

装饰者模式学习完毕 ！


^_^ 如有不当之处，欢迎指正

^_^ 参考资料
        《Head First 设计模式》Eric Freeman & Elisabeth Freeman with Kathy Sierra & Bert Bates著，O’Reilly Taiwan公司译，UMLChina改编

^_^ 测试代码托管链接
         https://github.com/JustryDeng…DesignPattern

^_^ 本文已经被收录进《程序员成长笔记》 ，笔者JustryDeng

justry_deng
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
装饰者模式Demo
11-20
装饰者模式是面向对象设计模式的一种，主要用于动态地给一个对象添加一些额外的职责，而不会改变该对象的类。这种模式允许我们独立于对象的类来扩展其功能，为对象增加新的行为或属性，同时保持了代码的可读性和可...
装饰者模式及实例
SSL 的博客
03-11 1694
带你了解装饰者模式，以及装饰者模式和集成以及代理模式的区别，同时还有简单的实例。
设计模式-装饰者模式在Java中的使用示例
BADAO_LIUMANG_QIZHI的博客
11-02 1268
是指在不改变原有对象的基础上，将功能附加到对象上，提供了比继承更有弹性的方案。适用场景：1、扩展一个类的功能或给一个类添加职责。2、动态给一个对象添加功能，这些功能可以再动态地撤销。3、生活中的应用比如给房子装修、给煎饼果子加肠、给蛋糕加巧克力。注：博客：关注公众号霸道的程序猿获取编程相关电子书、教程推送与免费下载。
Java 设计模式——装饰者模式
最新发布
代码星辰的博客
07-16 930
本文介绍了装饰者模式的相关知识。
设计模式3-装饰者模式（Decorator)全面解析+案例实践+总结
chen
09-09 3572
本文是对面向对象设计模式--装饰者模式的全面解析，主要分为定义解析、以咖啡店案例讲解装饰者模式、多案例练习加深对装饰者模式的理解、最后总结知识要点与装饰者模式的一些优缺点与适用场景。 第一篇：定义解析 策略模式是GoF四人帮整理的《设计模式-可复用面向对象软件基础》一书中23种设计模式中归类为结构型模式中的一种，23种设计模式根据它们的用途分为三大类：5种创建型模式、7种结构型模式、11种行为...
设计模式之【装饰者模式】，实现“穿衣打扮”自由原来这么简单
秃了也弱了
05-10 1246
装饰者模式（Decorator Pattern），也称为包装模式（Wrapper Pattern）、装饰器模式，是指在不改变原有对象的基础之上，将功能附加到对象上，提供了比继承更有弹性的替代方案（扩展原有对象的功能），属于结构型模式。在 GoF 的《设计模式》一书中，对装饰者模式是这样理解的：动态地给一个对象添加一些额外的职责，就增加功能来说，装饰者模式相比生成子类更灵活。装饰者模式的核心是扩展功能。使用装饰者模式可以透明且动态地扩展类的功能。装饰器模式主要解决。
JavaScript装饰者模式原理与用法实例详解
10-15
JavaScript装饰者模式是一种设计模式，它允许我们向对象动态地添加新功能，同时又不破坏对象原有的结构。这种模式在不改变对象自身的基础上，通过包裹（wrapping）对象并扩展其行为来达到增强功能的目的。装饰者模式...
java设计模式系列之装饰者模式
09-02
装饰者模式(Decorator Pattern)是一种在不改变原有对象的前提下，通过包装对象来扩展其功能的设计模式。它属于结构型模式，适用于需要灵活扩展对象功能但又不想通过子类化来实现的情况。 在Java中，装饰者模式的...
装饰者模式Android实例
07-30
装饰者模式是设计模式的一种，属于结构型模式，它的主要目的是动态地给对象添加新的行为或职责，而无需改变对象的原始代码。在Android开发中，装饰者模式的应用相当广泛，尤其是在视图组件的扩展和功能增强上。下面...
JAVA装饰者模式（从现实生活角度理解代码原理）
09-01
装饰者模式是面向对象设计中的一种结构型设计模式，它允许在不修改对象本身的情况下，通过添加新的行为或属性来扩展对象的功能。这种模式的核心思想是将装饰和对象分离，使得装饰过程可以在运行时动态进行。 在Java...
JavaScript设计模式之装饰者模式实例详解
10-17
装饰者模式是一种设计模式，它允许在不修改对象本身的情况下动态地给对象添加新的行为或属性。这种模式在JavaScript中非常实用，因为它提供了扩展对象功能的灵活方式，避免了使用继承带来的复杂性。 在JavaScript中...
PHP设计模式之装饰者模式
10-28
装饰者模式的解决方案是创建装饰类，如`CondimentDecorator`，它也是`Beverage`的子类，但其主要职责是装饰其他`Beverage`对象，如`Milk`和`Sugar`。这些装饰类持有`Beverage`对象的引用，并在需要时调用其方法，...
装饰者模式代码demo
11-26
装饰者模式是一种结构型设计模式，它允许在运行时向对象添加新的行为或职责，而无需修改对象的源代码。这种模式通过将对象包装在一个装饰类中来实现，装饰类与原类有相同的接口，因此可以透明地替换或增强原有对象的...
设计模式--装饰者模式java例子
02-06
装饰者模式是软件设计模式中的一种结构型模式，它的主要目的是动态地给对象添加新的功能，而无需修改原有代码。在Java中，装饰者模式通常通过继承和组合来实现，它提供了一种比继承更灵活的方式来扩展对象的功能。...
详解设计模式之装饰者模式[以奶茶为案例介绍]
NoviceZ的博客
09-04 751
背景案例介绍 以奶茶为例,如下图所示,Beverage(饮料)是一个抽象类，类里面有一个description(描述)实例用来描述该奶茶,可以描述出奶茶的分类,奶茶有很多种分类,比如抹茶，波霸，玛奇朵，奶绿等等。还有一个cost()方法,用于给子类继承,实现每种奶茶的各自价格. 众所周知,我们每个人去买奶茶,可能还需要往奶茶里面加一些配料,如红豆,燕麦,布丁,奶霜等等,但是每种配料的价格也不尽相同,每款奶茶的价格也不一定相同,所以刚开始OO设计师就得设计出无数个类(因为我每种配料可以加多份,如我加两
装饰者模式案例
u010574271的博客
01-15 311
前言 装饰者模式是指在不改变原有对象的基础上，将功能附加在对象上，提供了比继承者更有弹性方案。 案例 在现实生活中，我们买车一般有基础配置、中配、高配等，在这里我们就可以应用装饰者模式来这种情况进行描述 创建车辆接口 首先我们创建一个车辆接口，里面有两个方法，分别用于获取描述信息以及价格 ICar public interface ICar { public String getMsg(); public int getPrice(); } 创建基础版车 NormalCard public
装饰者模式示例demo
大龙的博客
07-16 483
介绍 在不改变类的源代码或者不使用继承类的基础上动态地为一个对象增加新的功能(OCP原则，即开闭原则) 示例demo 背景：在火锅中任意加自己喜欢吃的菜品 装饰者抽象类： public abstract class DecoratorComponent { /** * 加菜 */ public abstract void addGreens(); }...
设计模式系列：装饰者模式
有心好书
02-28 928
一.引入1.案例  比如，三个继承关系：Father，Son，GrandSon三个类，我要在son类上增加一些功能怎么办？2.面向实现编程方案  修改Son，这种方案会有大问题，因为你增强的功能是是修改Son的方法还是增加Son的方法，是否会对GrandSon造成影响呢？3.面向设计编程方案  通过建立SonDecorator类来修饰Son类，相当于创建了一个新的类，这个对原有程序没有改变，通过扩展
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值