装饰模式的定义:

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

  遵循的设计原则是开闭原则,也是对扩展开放,对修改关闭。

下面是类图

示例代码

  1. /**
  2. *定义被装饰者
  3. *
  4. */
  5. public interface Human {
  6.  
  7. public void wearClothers();
  8.  
  9. public void walkToWhere();
  10. }
  11.  
  12. /**
  13. * 定义抽象装饰者
  14. *
  15. */
  16. public abstract class Decorate implements Human {
  17.  
  18. Human human;
  19.  
  20. public Decorate(Human human) {
  21. this.human = human;
  22. }
  23.  
  24. public void wearClothers() {
  25. this.human.wearClothers();
  26. }
  27.  
  28. public void walkToWhere() {
  29. this.human.walkToWhere();
  30. }
  31. }
  32.  
  33. /**
  34. *
  35. *装饰者 zero
  36. */
  37. public class DecorateZero extends Decorate{
  38.  
  39. public DecorateZero(Human human) {
  40. super(human);
  41. }
  42.  
  43. @Override
  44. public void walkToWhere() {
  45. super.walkToWhere();
  46. System.out.println("Zero.............walkToWhere");
  47. }
  48.  
  49. @Override
  50. public void wearClothers() {
  51. super.wearClothers();
  52. System.out.println("Zero.............wearClothers");
  53. }
  54. }
  55.  
  56. /**
  57. * 装饰者two
  58. *
  59. */
  60. public class DecorateTwo extends Decorate{
  61.  
  62. public DecorateTwo(Human human) {
  63. super(human);
  64. }
  65. @Override
  66. public void walkToWhere() {
  67. super.walkToWhere();
  68. System.out.println("Two.............walkToWhere");
  69. }
  70.  
  71. @Override
  72. public void wearClothers() {
  73. super.wearClothers();
  74. System.out.println("Two.............wearClothers");
  75. }
  76. }
  77.  
  78. //
  79. public class DecorateFirst extends Decorate{
  80.  
  81. public DecorateFirst(Human human) {
  82. super(human);
  83. }
  84.  
  85. @Override
  86. public void walkToWhere() {
  87. super.walkToWhere();
  88. System.out.println("First.............walkToWhere");
  89. }
  90.  
  91. @Override
  92. public void wearClothers() {
  93. super.wearClothers();
  94. System.out.println("First.............wearClothers");
  95. }
  96. }
  97.  
  98. /**
  99. *
  100. *测试代码
  101. */
  102. public class Test {
  103.  
  104. public static void main(String[] args) {
  105. DecorateZero zero=new DecorateZero(new DecorateFirst(new DecorateTwo(new Human() {
  106. //这里装饰者原有的行为,这里我没有具体去写实现类。
  107. @Override
  108. public void wearClothers() {
  109. // TODO Auto-generated method stub
  110. System.out.println("1111111wearClothers1111111");
  111.  
  112. }
  113.  
  114. @Override
  115. public void walkToWhere() {
  116. // TODO Auto-generated method stub
  117. System.out.println("1111111walkToWhere1111111");
  118. }
  119. })));
  120. zero.walkToWhere();
  121. System.out.println("*******************************************");
  122. zero.wearClothers();
  123. }
  124. }
  125.  
  126. //测试结果
  127. 1111111walkToWhere1111111
  128. Two.............walkToWhere
  129. First.............walkToWhere
  130. Zero.............walkToWhere
  131. *******************************************
  132. 1111111wearClothers1111111
  133. Two.............wearClothers
  134. First.............wearClothers
  135. Zero.............wearClothers

关键点:
1、Decorator抽象类中,持有Human接口,方法全部委托给该接口调用,目的是交给该接口的实现类即子类进行调用。
2、Decorator抽象类的子类(具体装饰者),里面都有一个构造方法调用super(human),这一句就体现了抽象类依赖于子类实现即抽象依赖于实现的原则。因为构造里面参数都是Human接口,只要是该Human的实现类都可以传递进去,即表现出Decorator dt = new Decorator_second(new Decorator_first(new
Decorator_zero(human)));这种结构的样子。所以当调用dt.wearClothes();dt.walkToWhere()的时候,又因为每个具体装饰者类中,都先调用super.wearClothes和super.walkToWhere()方法,而该super已经由构造传递并指向了具体的某一个装饰者类(这个可以根据需要调换顺序),那么调用的即为装饰类的方法,然后才调用自身的装饰方法,即表现出一种装饰、链式的类似于过滤的行为。
3、具体被装饰者类,可以定义初始的状态或者初始的自己的装饰,后面的装饰行为都在此基础上一步一步进行点缀、装饰。
4、装饰者模式的设计原则为:对扩展开放、对修改关闭,这句话体现在我如果想扩展被装饰者类的行为,无须修改装饰者抽象类,只需继承装饰者抽象类,实现额外的一些装饰或者叫行为即可对被装饰者进行包装。

装饰Java.io类

java.io包内的类太多了,简只是……”排山倒海“,其实是因为里面许多类都是装饰者,其实java.io也引出装饰者模式的一个缺点:利用装饰着模式,常常设计中有大量的小类,数量实在太多,造成使用者非常大的困扰。了解装饰者模式的原理看起就会简单多了。

编写自己的java.io装饰者

功能:把输入的大写字母写成小写
例如:This is LONGHAIBO,使用此装饰者变成this is longhaibo

  1. public class TestDecorate {
  2.  
  3. public static void main(String[] args) {
  4.  
  5. int c;
  6. try (InputStream in = new LowerCaseIputStream(new BufferedInputStream(
  7. new FileInputStream("src/decorate.txt")))) {
  8. while ((c=in.read())>0) {
  9. System.out.print((char)c);
  10. }
  11. } catch (Exception e) {
  12. // TODO: handle exception
  13. e.printStackTrace();
  14. }
  15.  
  16. }
  17. }
  18.  
  19. /**
  20. * Java io 装饰者模式
  21. * 功能:把输入的大写字母写成小写
  22. * 例如:This is LONGHAIBO,使用此装饰者变成this is longhaibo
  23. *
  24. */
  25. class LowerCaseIputStream extends FilterInputStream {
  26.  
  27. protected LowerCaseIputStream(InputStream in) {
  28. super(in);
  29. }
  30. //针对字节
  31. @Override
  32. public int read() throws IOException {
  33. int c=super.read();
  34. return (c==-1?c:Character.toLowerCase((char)c));
  35. }
  36. //针对字节数组
  37. @Override
  38. public int read(byte[] b, int off, int len) throws IOException {
  39. int result=super.read(b, off, len);
  40. for (int i = off; i < off+result; i++) {
  41. b[i]=(byte)Character.toLowerCase((char)b[i]);
  42. }
  43. return result;
  44. }
  45.  
  46. }

输出结果

this is longhaibo

参考资料

head_first设计模式(中文版)

http://blog.csdn.net/jason0539/article/details/22713711

  

Decorate Pattern 装饰者模式的更多相关文章

  1. Decorator Pattern (装饰者模式)

    装饰者模式( Decorator Pattern ) 意图 : 动态的给一个对象添加一些额外的功能,IO这块内容体现出了装饰模式,Decorator模式相比生成子类更为灵活. 角色 : 1)抽象构件角 ...

  2. 浅谈设计模式--装饰者模式(Decorator Pattern)

    挖了设计模式这个坑,得继续填上.继续设计模式之路.这次讨论的模式,是 装饰者模式(Decorator Pattern) 装饰者模式,有时也叫包装者(Wrapper),主要用于静态或动态地为一个特定的对 ...

  3. java之装饰器模式

    Decorator Pattern(装饰器模式),定义:Attach additional responsibilities to an object dynamically. Decorators  ...

  4. 设计模式(三):“花瓶+鲜花”中的装饰者模式(Decorator Pattern)

    在前两篇博客中详细的介绍了"策略模式"和“观察者模式”,今天我们就通过花瓶与鲜花的例子来类比一下“装饰模式”(Decorator Pattern).在“装饰模式”中很好的提现了开放 ...

  5. C#设计模式之装饰者模式(Decorator Pattern)

    1.概述 装饰者模式,英文名叫做Decorator Pattern.装饰模式是在不必改变原类文件和使用继承的情况下,动态地扩展一个对象的功能.它是通过创建一个包装对象,也就是装饰来包裹真实的对象. 2 ...

  6. java_设计模式_装饰者模式_Decorator Pattern(2016-07-28)

    装饰模式又名包装(Wrapper)模式.装饰模式以对客户端透明的方式扩展对象的功能,是继承关系的一个替代方案. 装饰模式的结构 装饰模式以对客户透明的方式动态地给一个对象附加上更多的责任.换言之,客户 ...

  7. 设计模式 - 装饰者模式(Decorator Pattern) Java的IO类 用法

    装饰者模式(Decorator Pattern) Java的IO类 用法 本文地址: http://blog.csdn.net/caroline_wendy/article/details/26716 ...

  8. 设计模式 - 装饰者模式(Decorator Pattern) 具体解释

    装饰者模式(Decorator Pattern) 具体解释 本文地址: http://blog.csdn.net/caroline_wendy/article/details/26707033 装饰者 ...

  9. 设计模式学习--装饰者模式(Decorator Pattern)

    概念: 装饰者模式(Decorator Pattern): 动态地将功能添加到对象,相比生成子类更灵活,更富有弹性. 解决方案: 装饰者模式的重点是对象的类型,装饰者对象必须有着相同的接口,也也就是有 ...

随机推荐

  1. Git 命令清单

    这份命令清单并不完善,后期会根据使用情况再进行更改. 操作分支项目 1 下载仓库的一个分支(baooab-patch-1)的代码 git clone -b baooab-patch-1 https:/ ...

  2. 如何在RCP程序中添加一个banner栏

    前言:这段时间还算比较空闲,我准备把过去做过的有些形形色色,甚至有些奇怪的研究总结一下,也许刚好有人用的着也不一定,不枉为之抓耳挠腮的时光和浪费的电力.以前有个客户提出要在RCP程序中添加一个bann ...

  3. java正则表达式【大全】

    [正则表达式]文本框输入内容控制整数或者小数:^[0-9]+\.{0,1}[0-9]{0,2}$只能输入数字:"^[0-9]*$".只能输入n位的数字:"^\d{n}$& ...

  4. SQL2008触发器

    最近第一次接触触发器,感觉很是新奇,也很是蛋疼,因为老板要求的是在触发器中获取用户信息,并把对表的操作进行记录,后者实现到时比较简单,前者确实让我纠结了好久,其实百度了一下关于SQL2008触发器的文 ...

  5. js的match()方法介绍

    定义和用法 match() 方法可在字符串内检索指定的值,或找到一个或多个正则表达式的匹配. 该方法类似 indexOf() 和 lastIndexOf(),但是它返回指定的值,而不是字符串的位置. ...

  6. quantile normalization原理

    对于芯片或者其它表达数据来说,最常见的莫过于quantile normalization啦. 那么它到底对我们的表达数据做了什么呢?首先要么要清楚一个概念,表达矩阵的每一列都是一个样本,每一行都是一个 ...

  7. XML特殊符号

    在XML中"<" 字符和"&"字符是严格禁止使用的.要使用这几种字符需要使用它们的实体, 下面是五个在XML文档中预定义好的实体:< < ...

  8. OpenLayers控制瓦片的绽放级别

    先说说这个功能可能使用到的地方,当我们下载的网上瓦片或者矢量数据的第一级或开始几级效果不是很好时,我们就就想让用户看到这些级别的瓦片.实现这个功能比较简单,主要就是修改Openlayers.map的i ...

  9. angularjs指令系统系列课程(1):目录

    angularjs里面有一套十分强大的指令系统 比如内置指令:ng-app,ng-model,ng-repeat,ng-init,ng-bind等等 从现在开始我们讲解AngularJS自定义指令, ...

  10. CentOS 6.5 yum安装配置lnmp服务器(Nginx+PHP+MySQL)

    以下全部转载于  http://blog.csdn.net/lane_l/article/details/20235909 本人于今晚按照该文章使用centos 6.7 64bit安装成功,做个备份, ...