精华内容
下载资源
问答
  • java 装饰器模式

    2013-08-15 13:56:04
     记得以前听一个高手说java.io包采用了了装饰器模式,当时不是很明白什么事装饰器模式,现在,网上看了一下说明和帮助的例子,他们的例子是这样的。  定义 Decorator装饰器,顾名思义,就是动态地给一个对象...

    原文:http://chenhua-1984.iteye.com/blog/565629

     记得以前听一个高手说java.io包采用了了装饰器模式,当时不是很明白什么事装饰器模式,现在,网上看了一下说明和帮助的例子,他们的例子是这样的。

       定义

    Decorator装饰器,顾名思义,就是动态地给一个对象添加一些额外的职责,就好比为房子进行装修一样。因此,装饰器模式具有如下的特征:

    它必须具有一个装饰的对象。

    它必须拥有与被装饰对象相同的接口。

    它可以给被装饰对象添加额外的功能。

    用一句话总结就是:保持接口,增强性能。

    装饰器通过包装一个装饰对象来扩展其功能,而又不改变其接口,这实际上是基于对象的适配器模式的一种变种。它与对象的适配器模式的异同点如下。

    相同点:都拥有一个目标对象。

    不同点:适配器模式需要实现另外一个接口,而装饰器模式必须实现该对象的接口。

     

    Sourcable类的源代码如程序 12-22 所示,其定义了一个接口函数 operation() 。

    程序12-22   源接口 Sourcable.java

    Java代码   收藏代码
    1. package pattern.decorator;  
    2.   
    3. public interface Sourcable {  
    4.     public void operation();  
    5.   
    6. }  
     

    (2 ) Source.java 是 Sourcable.java 的一个实现,其函数 operation() 负责往控制台输出一个字符串:原始类的方法。其源代码如程序 12-23 所示。

    程序12-23   源类 Source.java

    Java代码   收藏代码
    1. package pattern.decorator;  
    2.   
    3. public class Source implements Sourcable {  
    4.   
    5.     public void operation() {  
    6.         System.out.println("原始类的方法");  
    7.     }  
    8.   
    9. }  
     

    (3 )装饰器类 Decorator1.java 采用了典型的对象适配器模式,它首先拥有一个 Sourcable 对象 source ,该对象通过构造函 数进行初始化。然后它实现了 Sourcable.java 接口,以期保持与 source 同样的接口,并在重写的operation() 函数中调用  source 的 operation() 函数,在调用前后可以实现自己的输出,这就是装饰器所扩展的功能。其源代码如程序 12-24 所示。

    程序12-24   装饰器类 Decorator1.java

    Java代码   收藏代码
    1. package pattern.decorator;  
    2.   
    3. public class Decorator1 implements Sourcable {  
    4.   
    5.     private Sourcable sourcable;  
    6.     public Decorator1(Sourcable sourcable){  
    7.         super();  
    8.         this.sourcable=sourcable;  
    9.     }  
    10.       
    11.     public void operation() {  
    12.         System.out.println("第一个装饰器前");  
    13.         sourcable.operation();  
    14.         System.out.println("第一个装饰器后");  
    15.   
    16.     }  
    17.   
    18. }  
     

    装饰器类Decorator2.java 是另一个装饰器,不同的是它装饰的内容不一样,即输出了不同的字符串。其源代码如程序 12-25 所示。

    程序12-25   装饰器类 Decorator2.java

    Java代码   收藏代码
    1. package pattern.decorator;  
    2.   
    3. public class Decorator2 implements Sourcable {  
    4.   
    5.     private Sourcable sourcable;  
    6.     public Decorator2(Sourcable sourcable){  
    7.         super();  
    8.         this.sourcable=sourcable;  
    9.     }  
    10.     public void operation() {  
    11.         System.out.println("第二个装饰器前");  
    12.         sourcable.operation();  
    13.         System.out.println("第二个装饰器后");  
    14.   
    15.     }  
    16.   
    17. }  
     

    装饰器类Decorator1.java 是第三个装饰器,不同的是它装饰的内容不一样,即输出了不同的字符串。其源代码如程序 12-26 所示。

    程序12-26   装饰器类 Decorator3.java

    Java代码   收藏代码
    1. package pattern.decorator;  
    2.   
    3. public class Decorator3 implements Sourcable {  
    4.   
    5.     private Sourcable sourcable;  
    6.     public Decorator3(Sourcable sourcable){  
    7.         super();  
    8.         this.sourcable=sourcable;  
    9.     }  
    10.     public void operation() {  
    11.         System.out.println("第三个装饰器前");  
    12.         sourcable.operation();  
    13.         System.out.println("第三个装饰器后");  
    14.   
    15.     }  
    16.   
    17. }  
     

    这时,我们就可以像使用对象的适配器模式一样来使用这些装饰器,使用不同的装饰器就可以达到不同的装饰效果。如程序12-27 所示,首先需要创建一 个源类对象 source ,然后根据将对象使用 Decorator1 来装饰,并以此使用 Decorator2 、 Decorator3 进行装饰,装饰后的对象 同样具有与 source 同样的接口。

    程序12-27   测试类 DecoratorTest.java

    Java代码   收藏代码
    1. package pattern.decorator;  
    2.   
    3. public class DecoratorTest {  
    4.   
    5.     /** 
    6.      * @param args 
    7.      */  
    8.     public static void main(String[] args) {  
    9.         Sourcable source = new Source();  
    10.   
    11.         // 装饰类对象   
    12.         Sourcable obj = new Decorator1(new Decorator2(new Decorator3(source)));  
    13.         obj.operation();  
    14.     }  
    15.   
    16. }  
     

    运行该程序的输出如下:

    第1 个装饰器装饰前

    第2 个装饰器装饰前

    第3 个装饰器装饰前

    原始类的方法

    第3 个装饰器装饰后

    第2 个装饰器装饰后

    第1 个装饰器装饰后

    从输出的结果可以看出,原始类对象source 依次被 Decorator1 、 Decorator2 、 Decorator3 进行了装饰。


    展开全文
  • java装饰器模式

    千次阅读 2016-05-30 14:42:49
    装饰器增加功能 6 public abstract void doCoding(); 7 8 } 1 package com.test.patten.decorator; 2 3 public class ManagerA extends Manager { 4 private ...


    意图:动态的将责任附加到对象上
    什么时候使用:
    1.在不影响其他对象的情况下,以动态、透明的方式给单个对象添加职责
    2.处理那些可以撤销的职责
    3.当不能采用生成子类的方式进行扩充时
    结构图:

    示例代码:

    1 package com.test.patten.decorator;
    2 
    3 public interface Person {
    4     void doCoding();
    5 }
    复制代码
     1 package com.test.patten.decorator;
     2 
     3 public class Employee implements Person {
     4 
     5     @Override
     6     public void doCoding() {
     7         System.out.println("程序员加班写程序啊,写程序,终于写完了。。。");
     8     }
     9 
    10 }
    复制代码
    复制代码
    1 package com.test.patten.decorator;
    2 
    3 public abstract class Manager implements Person{
    4     
    5     //装饰器增加功能
    6     public abstract void doCoding();
    7 
    8 }
    复制代码
    复制代码
     1 package com.test.patten.decorator;
     2 
     3 public class ManagerA extends Manager {
     4     private Person person;//给雇员升职
     5     
     6     public ManagerA(Person person) {
     7         super();
     8         this.person = person;
     9     }
    10     @Override
    11     public void doCoding() {
    12         doEarlyWork();
    13         person.doCoding();        
    14     }
    15     /**
    16      * 项目经理开始前期准备工作
    17      */
    18     public void doEarlyWork() {
    19         System.out.println("项目经理A做需求分析");
    20         System.out.println("项目经理A做架构设计");
    21         System.out.println("项目经理A做详细设计"); 
    22     }
    23 }
    复制代码
    复制代码
     1 package com.test.patten.decorator;
     2 
     3 public class ManagerB extends Manager {
     4     private Person person;//给雇员升职
     5     
     6     public ManagerB(Person person) {
     7         super();
     8         this.person = person;
     9     }
    10     @Override
    11     public void doCoding() {
    12         person.doCoding();
    13         doEndWork();
    14     }
    15     /**
    16      * 项目经理开始项目收尾工作
    17      */
    18     public void doEndWork() {
    19         System.out.println("项目经理B 在做收尾工作");
    20     }
    21     
    22 }
    复制代码

    测试一下:

    复制代码
     1 package com.test.patten.decorator;
     2 
     3 public class Client {
     4     public static void main(String args[]){
     5         Person employee = new Employee();
     6         employee = new ManagerA(employee);//赋予程序猿项目经理A职责
     7         employee = new ManagerB(employee);//赋予程序猿项目经理B职责
     8         
     9         employee.doCoding();
    10     }
    11 }
    复制代码
    项目经理A做需求分析
    项目经理A做架构设计
    项目经理A做详细设计
    程序员加班写程序啊,写程序,终于写完了。。。
    项目经理B 在做收尾工作

     实际应用中的例子:java i/o

    应用到的设计原则:对扩展开放,对修改关闭

    优缺点:

    1.装饰者类反应出被装饰的组件类型

    2.装饰者类可以在被装饰者的行为前面或后面加上自己的行为,甚至取代被装饰者的行为,达到特定的目的

    3.可以用无数个装饰者包装一个组件,装饰者类会导致设计中出现许多小对象,过度使用会让程序变的复杂

    4.装饰者一般对组件的客户是透明的,除非客户程序依赖于组件的具体类型

    展开全文
  • java 23 种设计模式-10-java 装饰器模式(Decorator Pattern).pdf
  • Java 装饰器模式详解

    千次阅读 2017-02-22 16:22:14
    在上面的几篇文章中,着重介绍了java 中常见的`IO` 相关知识,在学习的过程中,发现IO包中是用了大量的装饰器模式,为了彻底的学习IO,今天就来揭开装饰器模式的面纱。 为了弄明白装饰器模式的本质,我查看了很多...

    转载请注明出处:http://blog.csdn.net/zhaoyanjun6/article/details/56488020


    前言

    在上面的几篇文章中,着重介绍了java 中常见的 IO 相关知识,在学习的过程中,发现 IO 包中是用了大量的装饰器模式,为了彻底的学习 IO,今天就来揭开装饰器模式的面纱。


    为了弄明白装饰器模式的本质,我查看了很多资料,发现有很多文章要么说的很苦涩,要么举的例子不恰当。

    其实我们可以这样理解装饰器模式, 就拿自己举例子,你把自己裸体的样子,想象成被装饰的对象。你的鞋子,你的寸衣,你的外套,你的手表,你的帽子 等等,都是你的装饰物,你和这些装饰物,是装饰和被装饰的关系。


    实例展示

    好了,现在我们用代码的方法去理解这样概念。

    首先,我们发现,不管是裸体的人,还是你的鞋子、帽子,都有展示的功能,我们称之为show 方法。

    我们定义一个接口,它具有展示的功能,也就是show() , 

    package com.user;
    
    /**
     * 定义接口
     * @author T
     *
     */
    public interface AbstractPerson {
    
    	//具有展示的功能
    	void show() ;
    }
    现在应该定义一个裸体的自己了,Me 类

    package com.user;
    
    /**
     * 定义一个具体的人,就是被装饰者
     * @author T
     *
     */
    public class Me implements AbstractPerson {
    
    	@Override
    	public void show() {
    		System.out.println( "什么都没穿,我展示的是裸体");
    	}
    
    }
    下面该定义,鞋子,帽子,手表等 装饰物,等等先别急,我们应该先定义一个鞋子,帽子,手表的抽象父类  AbstractClothes 。 
    其实抽象的父类有一个构造函数,构造函数里面的参数是抽象的人类,这里的用法很巧妙,这也是能够实现装饰功能的一个必不可少的步骤。

    package com.user;
    
    /**
     * 定义抽象装饰物
     * @author T
     *
     */
    public abstract class AbstractClothes implements AbstractPerson {
    
    	AbstractPerson abstractPerson ;
    
    	public AbstractClothes( AbstractPerson abstractPerson ){
    		this.abstractPerson = abstractPerson ;
    	}
    
    	@Override
    	public void show() {
    		abstractPerson.show();
    	}
    
    }
    下面开始定义,帽子装饰物  Hat 类, 继承 AbstractClothes 类

    package com.user;
    
    /**
     * 帽子装饰物
     * @author T
     *
     */
    public class Hat extends AbstractClothes {
    
    	public Hat(AbstractPerson abstractPerson) {
    		super(abstractPerson);
    	}
    	
    	@Override
    	public void show() {
    		super.show();
    	    say();
    	}
    	
    	public void say(){
    		System.out.println( "我展示一个帽子");
    	}
    
    }
    定义鞋子装饰类 Shoes ,   继承 AbstractClothes 类

    package com.user;
    
    /**
     * 鞋子装饰物
     * @author T
     *
     */
    public class Shoes extends AbstractClothes {
    
    	public Shoes(AbstractPerson abstractPerson) {
    		super(abstractPerson);
    	}
    	
    	@Override
    	public void show() {
    		super.show();
    	    say();
    	}
    	
    	public void say(){
    		System.out.println( "我展示一双鞋子");
    	}
    }

    创建测试类 Test

    package com.user;
    
    public class Test {
    
    	public static void main(String[] args) {
    
    		//创建被装饰者
    		Me me = new Me() ;
    
    		//裸体的人被装饰了帽子 ,具有了展示帽子的能力
    		Hat hat = new Hat( me ) ;
    
    		// 带了帽子的人被装饰了鞋子,具有了展示鞋子的本领
    		Shoes shoes = new Shoes( hat ) ;
    
    		shoes.show();
    	}
    }
    运行结果:

    什么都没穿,我展示的是裸体
    我展示一个帽子
    我展示一双鞋子

    装饰器模式的类图

    在学习完了一个小例子之后,我们试着总结出装饰器模式的类图。

    装饰器模式类图:


    • Component抽象构件角色:真实对象和装饰对象有相同的接口。这样,客户端对象就能够以与真实对象相同的方式同装饰对象交互。
    • ConcreteCompoent具体构建角色(真实对象):定义一个将要接收附加责任的类。
    • Decorator装饰角色:持有一个抽象构件的引用。装饰对象接受所有客户端的请求,并把这些请求转发给真实的对象。这样,就能在真实对象调用前后增加新的功能。
    • ConcreteDecorate具体装饰角色:负责给构件对象增加新的功能。

    装模式在Java I/O库中的应用

    IO流实现细节:

    • Component抽象构件角色:io流中的InputStream,OutputStream,Reader,Writer
    • ConcreteComponent具体构件角色:io流中的FileInputStream,FileOutputStream
    • Decorate装饰角色:持有抽象构件的引用,FilterInputStream,FilterOutputStream
    • ConcreteDecorate具体装饰角色:负责给构件对象添加新的责任,BufferedInputStream,BufferedOutputStream等

    总结

    • 装饰模式(Decorate)也叫包装模式(Wrapper)
    • 装饰模式降低系统的耦合度,可以动态的增加或删除对象的责任,并使得需要装饰的具体构建类和具体装饰类可以独立变化,以便增加新的具体构建类和具体装饰类。

    优点

    •  扩展对象功能,比继承灵活,不会导致类个数急剧增加。
    • 可以对一个对象进行多次装饰,创造出不同行为的组合,得到功能更加强大的对象。
    • 具体构 件 类和具体装饰类可以独立变化,用户可以根据需要自己增加新的 具体构件子类和具体装饰子类。

    缺点

    • 产生很多小对象。大量小的对象占据内存,一定程度上影响性能。
    • 装饰模式易出错,调试排查比较麻烦。

    参考资料:

    Java设计模式学习09——装饰模式

    Java与模式:装饰(Decorator)模式



    展开全文
  • 装饰器模式 实际案例 定义 测试 实现方式 UML & Code UML Code 系列导航 装饰器模式 装饰器模式(Decorator Pattern)允许向一个现有的对象添加新的功能,同时又不改变其结构。 这种类型的设计...

    目录

    装饰器模式

    装饰器模式(Decorator Pattern)允许向一个现有的对象添加新的功能,同时又不改变其结构
    这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。

    这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能。

    实际案例

    类信息概览:

    类名说明
    Main.java方法的总入口
    RectanglePainter.java长方形绘图
    CirclePainter.java圆形绘图
    Painter.java绘图接口
    PainterDecorator.java绘图装饰器

    定义

    • RectanglePainter.java
    package com.ryo.design.pattern.note.decorator;
    
    /**
     * Created by bbhou on 2017/8/11.
     */
    public class RectanglePainter implements Painter {
        @Override
        public void draw() {
            System.out.println("Draw rectangle...");
        }
    }
    
    • CirclePainter.java
    package com.ryo.design.pattern.note.decorator;
    
    /**
     * Created by bbhou on 2017/8/11.
     */
    public class CirclePainter implements Painter {
        @Override
        public void draw() {
            System.out.println("Draw circle...");
        }
    }
    
    • Painter.java
    package com.ryo.design.pattern.note.decorator;
    
    /**
     * Created by bbhou on 2017/8/11.
     */
    public interface Painter {
    
        /**
         * 绘制
         */
        void draw();
    
    }
    
    • PainterDecorator.java
    package com.ryo.design.pattern.note.decorator;
    
    /**
     * Created by bbhou on 2017/8/11.
     */
    public class PainterDecorator implements Painter {
    
        private Painter painter;
    
        public PainterDecorator(Painter painter) {
            this.painter = painter;
        }
    
        @Override
        public void draw() {
            painter.draw();
            setBorderColor();
        }
    
        private void setBorderColor() {
            System.out.println("Set border color...");
        }
    
    }
    

    测试

    • Main.java
    /*
     * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
     * Copyright (c) 2012-2018. houbinbini Inc.
     * design-pattern All rights reserved.
     */
    
    package com.ryo.design.pattern.note.decorator;
    
    /**
     * <p> </p>
     *
     * <pre> Created: 2018/5/16 下午8:16  </pre>
     * <pre> Project: design-pattern  </pre>
     *
     * @author houbinbin
     * @version 1.0
     * @since JDK 1.7
     */
    public class Main {
    
        public static void main(String[] args) {
            Painter painter = new PainterDecorator(new CirclePainter());
            painter.draw();
    
            Painter painter2 = new PainterDecorator(new RectanglePainter());
            painter2.draw();
        }
    
    }
    
    • 测试结果
    Draw circle...
    Set border color...
    Draw rectangle...
    Set border color...

    实现方式

    UML & Code

    UML

    UML 图示如下

    Code

    代码地址

    装饰器模式

    系列导航

    系列导航

    展开全文
  • Java装饰器模式(Decorator)

    千次阅读 2017-01-30 10:58:21
     装饰模式又名包装(Wrapper)模式装饰模式以对客户端透明的方式扩展对象的功能,可以在不创建更多子类的情况下,将对象的功能加以扩展,是继承关系的一个替代方案。用意:动态地为对象添加一些额外的功能,就好比...
  • java装饰器模式与java.io包

    千次阅读 2012-12-12 15:31:18
    装饰器(Decorator)模式    Decorator设计模式是典型的结构型模式(在GOF的那本模式的Bible...(记住上面两种颜色的词汇,理解装饰器模式的精髓所在!)下面是GOF的《Element of reusable Object-Oriented
  • 这篇博客我们来继续讲结构型模式,上一篇的适配器模式,如果读者有看过的话,应该会知道结构型模式关键还是在于类的继承,接口的实现。互相组合来实现我们想要的代码结构。那这一次的装饰模式该从何讲起呢?...
  • 主要为大家详细介绍了Java装饰器设计模式,感兴趣的小伙伴们可以参考一下
  • 主要介绍了Java装饰器设计模式的相关资料,非常不错,具有参考借鉴价值,需要的朋友可以参考下
  • java装饰器模式

    千次阅读 2019-05-17 13:23:22
    装饰器模式 定义 装饰器模式又名包装(Wrapper)模式。装饰器模式以对客户端透明的方式拓展对象的功能,是继承关系的一种替代方案。 类图 角色 抽象构件(Component)角色:给出一个抽象接口,已规范准备接收附加责任...
  • 设计模式-Java实现装饰器模式 装饰器模式允许向一个现有的对象添加新的功能,同时又不改变其结构。通俗的说,装饰器模式可以给一个已经确定的对象添加额外功能而且不需要改变其类的代码。在Java中基础的IO流就运用了...
  • 主要为大家详细介绍了java设计模式之装饰器模式Decorator,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要为大家详细介绍了java实现装饰器模式Decorator Pattern,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 显然设计模式往往追求开闭原则,所以往往是面向接口编程,那么万事万物就是先写接口,把需求弄出来,这里以一辆车子在陆地上跑为基础,对它进行装饰,使它可以具备更多的"功能",达到装饰的效果.这里由于代码相对简单,直接...
  • 主要介绍了Java设计模式系列-装饰器模式,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Java装饰器模式

    千次阅读 2015-11-03 09:39:54
    本文主要是介绍《【C++】装饰器模式》(点击打开链接)的Java版。关于什么是装饰器模式就不再赘述了,这次主要说明从UML类图是如何与代码联系起来的。 还是从2012年上半年软件设计师的软考题来说明这个例子。 题目...
  • java 策略设计模式Comparable 和 ComparatorComparator 实现了策略模式 程序设计的基本目标是“将保持不变的事物与会发生改变的事物分离”,不是将进行比较的代码编写成不同的子程序。 而是使用策略模式,通过...
  • (七)装饰器模式 Decorator 装饰器模式是为了动态的给一个对象增加一些新功能。装饰对象与被装饰的对象需要实现同一个接口,装饰对象持有被装饰对象的实例。 (八)代理模式 已有方法使用时候需要对原有方法改进,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,066
精华内容 21,626
关键字:

java装饰器模式

java 订阅