zoukankan      html  css  js  c++  java
  • 学习:java设计模式—Decorator模式

    一、学习装饰着模式

    1、定义及作用

          该模式以对客户端透明的方式扩展对象的功能。

    2、涉及角色
          抽象构件角色:定义一个抽象接口,来规范准备附加功能的类。

          具体构件角色:将要被附加功能的类,实现抽象构件角色接口。

          抽象装饰者角色:持有对具体构件角色的引用并定义与抽象构件角色一致的接口。

          具体装饰角色:实现抽象装饰者角色,负责为具体构件添加额外功能。

     
      3、简单实现
    抽象构件角色java 代码:

    package com.pattern.decorator2;
    /**
     * 抽象构件角色
     * 
    @author zdw
     *
     
    */

    public interface Component
    {
        
    //默认方法A
        void functionA();
    }


    具体构件角色:
    package com.pattern.decorator2;
    /**
     * 具体构件角色
     * 
    @author zdw
     *
     
    */

    public class ConcreateComponent implements Component
    {
        
        
    public void functionA()
        
    {
            System.out.println(
    "Function A");
        }


    }


    抽象装饰者角色:
    package com.pattern.decorator2;

    /**
     * 抽象装饰者角色
     * 
     * 
    @author zdw
     * 
     
    */

    public class Decorator implements Component
    {
        
    //抽象构件角色的引用
        private Component component;
        
        
    public Decorator(Component component)
        
    {
            
    this.component = component;
        }


        
    public void functionA()
        
    {
            component.functionA();
        }


    }

    具体装饰者角色1:
    package com.pattern.decorator2;
    /**
     * 具体装饰者角色
     * 
    @author zdw
     *
     
    */

    public class ConcreateDecorator1 extends Decorator
    {
        
    public ConcreateDecorator1(Component component)
        
    {
            
    super(component);
        }


        @Override
        
    public void functionA()
        
    {
            
    super.functionA();
            
    this.functionB();
        }

        
    //根据自己的需要扩展
        private void functionB()
        
    {
            System.out.println(
    "function B");
        }

    }


    具体装饰者角色2:
    package com.pattern.decorator2;

    public class ConcreateDecorator extends Decorator
    {
        
    public ConcreateDecorator(Component component)
        
    {
            
    super(component);
        }


        @Override
        
    public void functionA()
        
    {
            
    super.functionA();
            
    this.functionC();
        }


        
    private void functionC()
        
    {
            System.out.println(
    "fucntion C");
        }

    }


    测试类:
    package com.pattern.decorator2;

    /**
     * 测试客户端
     * 
     * 
    @author zdw
     * 
     
    */

    public class Client
    {

        
    /**
         * 
    @param args
         
    */

        
    public static void main(String[] args)
        
    {
            
    // 一层套一层,进行方法组合
            Component component = new ConcreateDecorator(new ConcreateDecorator1(
                    
    new ConcreateComponent()));
            component.functionA();
        }


    }

    OO原则:动态地将责任附加到对象上。想要扩展功能,装饰者提供有别于继承的另一种选择。

    要点:
    1、继承属于扩展形式之一,但不见得是达到弹性设计的最佳方案。
    2、在我们的设计中,应该允许行为可以被扩展,而不须修改现有的代码。
    3、组合和委托可用于在运行时动态地加上新的行为。
    4、除了继承,装饰者模式也可以让我们扩展行为。
    5、装饰者模式意味着一群装饰者类,这些类用来包装具体组件。
    6、装饰者类反映出被装饰的组件类型(实际上,他们具有相同的类型,都经过接口或继承实现)。
    7、装饰者可以在被装饰者的行为前面与/或后面加上自己的行为,甚至将被装饰者的行为整个取代掉,而达到特定的目的。
    8、你可以有无所数个装饰者包装一个组件。
    9、装饰者一般对组建的客户是透明的,除非客户程序依赖于组件的具体类型。
    10、装饰者会导致设计中出现许多的小对象,如果过度使用,会让程序变得很复杂。

    二、从java.io包看装饰模式

    转自:http://tanshenghui.javaeye.com/blog/618724

    ===================================

    可从IO的类层次,IO框架的设计模式来论述。

    总体来说,IO可以分为字节流和字符流,不同在于字符流由字节流包装而来,在IO读入之后经过JVM处理,把字节流转换成字符流。而字符流的字符采用哪种字符编码实现由JVM默认编码决定。
    而每个流都分输入和输出,所以,总体来说,IO有四个顶层类:
    InputStream
    OutputStream
    Reader
    Writer

    而作为机器级别与机器交互的则是字节流:
    InputStream
    OutputStream

    以IO的中间类,进行字节流到字符流的转换过渡,通常可作为字符流类的构造参数,可指定编码:
    InputStreamReader
    OutputStreamWriter

    而字节流和字符流的缓冲容器来看有byte和char之分,所以派生出:
    ByteArrayInputStream
    ByteArrayOutputStream
    CharArrayInputStream
    CharArrayOutputStream

    以上类只是表示流的表示形式,而在传输形式上还表现为是否有缓冲。所以,可以派生出子类为可缓冲类:
    BufferInputStream
    BufferOutputStream
    BufferReader
    BufferWriter

    每一个顶层类都有对目录文件(File)的支持:
    FileInputStream
    FileOutputStream
    FileReader
    FileWriter

    在Java中,一个强大的功能就是可以对对象进行序列化,转成二进制文件输出,也就是字节流输出而不是字符流输出,所以有顶层的InputStream和OutputStream派生类:
    ObjectInputStream
    ObjectOutputStream

    流包括了节点流和过滤流,注意的是过滤流,可在读写的同时对数据进行操作,并且实现了同步操作,顶层过滤流类:
    FilterInputStream
    FilterOutputStream
    其子类则在其基础上,对节点流进行封装,常见子类有:
    BufferInputStream          BufferOutputStream
    DataInputStream            DataOutputStream
    LineNumberInputStream      PrintStream
    可参考子类的构造方法。

    以上IO操作几乎就是把流装载到内存中,对其进行操作的时候是顺序读写,而需要随机读写时:
    RandomAccessFile

    从整个类框架的结构实现的接口来看,顶层类:
    InputStream implements Closable,
    OutputStream implements Closable, Flushable
    Reader implements Closable, Readable
    Writer implements Closable, Flushable, Appendable
    各个接口方法:
    Closable: close();
    Flushable: flush();
    Readable: read(CharBuffer cb);
    Appendable: append();
    从IO类使用时的规则来看,实现这些方法就是很自然的了,也是必须要实现的。如:流使用完必须关闭,流输出前必须刷新。

    注意的是,这四个顶层类都没有实现Serializable接口。
    java.io.Serializable虽然属于IO框架,但其并不是直接作用于IO框架四个顶层IO类及其子类,而是作用于其它对象,使其可被序列化,再通过IO类对其进行输入输出。如:File、ObjectStreamClass、String。

    Java IO 框架中主要应用了两个设计模式:装饰模式和适配器模式。

    姑且就把Java IO划分为元素和行为两个部分,元素则是适配,行为则是装饰加强。

    适配器模式主要在于字节流到字符流的转换和元素的包装上,如类:InputStreamReader, CharArrayReader, FileReader, PipedReader, StringReader。
    装饰模式主要在对流的强化之中,如缓冲、过滤、行定位等,如类:BufferedReader, FilterReader, LineNumberReader。

    一个典型的例子就是:
    BufferReader br = new BufferReader(new InputStreamReader(System.in));
    综合了两种模式:把InputStream适配成InputStreamReader,再把InputStreamReader加强装饰城BufferedReader。
  • 相关阅读:
    Spring IOC之容器概述
    SQL Server之记录筛选(top、ties、offset)汇总
    [译]Java 设计模式之单例
    [译]Java 设计模式之适配器
    [译]Java 设计模式之桥接
    [译]Java 设计模式之装饰器
    [译]Java 设计模式 之模板方法
    [译]Java 设计模式之抽象工厂
    [译]Java 设计模式之工厂
    传入两个字符串,确认其中一个字符串重新排序后能否变为另一个字符串(也就是两个字符串相等)
  • 原文地址:https://www.cnblogs.com/forlina/p/2088213.html
Copyright © 2011-2022 走看看