黑马程序员JAVA基础IO流中的装饰设计模式

装饰设计模式：

　　当想要对已有的对象进行功能增强时，可以定义类，将已有的对象传入，基于已有的功能，并提供加强功能。那么，自定义的该类称为装饰类。

　　装饰类通常会通过构造方法接收被装饰的类，并基于被装饰的对象的功能，提供更强的功能。

  

装饰和继承的区别：

　　装饰模式：

　　MyReader // 专门用于读取数据的类。

　　　　|--MyTextReader 

　　　　|--MyMediaReader 

　　　　|--MyDataReader 

　　　　|--MyBufferReader // 装饰类：增强MyReader 读取功能。

　　此时 MyBufferReader 类如： 

     class MyBufferReader extends MyReader {
         MyBufferReader(MyReader r){
         }
     }

　　继承： 

　　MyReader // 专门用于读取数据的类。

　　　　|--MyTextReader 

　　　　　　|--MyBufferTextReader

　　　　|--MyMediaReader 

　　　　　　|--MyBufferMediaReader

　　　　|--MyDataReader 

　　　　　　|--MyBufferDataReader 

    class MyBufferReader
     {
         MyBufferReader(MyTextReader text) {}
         MyBufferReader(MyMediaReader media){}
         如果要添加子类。如MyBufferDataReader。则要修改此处的代码。。。
         所以使用继承的话，代码不安全。
     }

　　通过如上的比较，可以知道：装饰模式比继承要灵活。避免了继承体系的臃肿，而且降低了类与类之间的关系。

　　装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强的功能，所以装饰类和被装饰类通常都属于一个体系中的。

　　模拟: BufferedReader 类，并完成其的特用方法 readLine() ;

　　> readLine() : 每次读一行数据。

import java.io.*; 
public class MyBufferedReader {
    private  FileReader fr = null ;
    public MyBufferedReader(FileReader fr) {
        this.fr = fr ;
    }
//    模拟 readLine 方法，一次读一行
    public String MyReadLine() throws IOException{
//        定义一个临时容器
        StringBuilder sb = new StringBuilder() ;  
        int ch = 0 ;  
        while ((ch = fr.read()) != -1) {
            if (ch == '\r')
                continue ; 
            if (ch == '\n')
                return  sb.toString() ; 
            sb.append((char)ch) ; 
        }
        if (sb.length() != 0) 
            return sb.toString() ;
        return null ;
    }
    public void myClose() throws IOException {
        fr.close() ;
    }
}

　　模拟：BufferedInputStream 类，自定义MyBufferedInputStream 类。

　　首先：分析BufferedInputStream 类的原理：1、从硬盘上读取数据到缓冲区（new FileInputStream("....").read(buf) ;) 。

　　　　　　　　　　　　　　　　　　　　　　　2、从缓冲区读取数据。 

import java.io.*; 
public class MyBufferedInputStream {
    private InputStream in  ; 
    
//    定义容器：
    private byte[] buf = new byte[1024] ; 
//    定义计数器：
    private int pos = 0 ; 
    private int count = 0 ;
    
    MyBufferedInputStream(InputStream in ) {
        this.in = in ; 
    }
    
//    一次读一个字节，从缓冲区（字节数组）获取。
    public int MyRead() throws IOException {
//        通过in对象读取硬盘上数据，并存储buf中。
        if(count == 0) {
            count = in.read(buf) ; 
            if (count < 0)
                return -1 ; 
            pos = 0 ; 
            byte b = buf[pos] ; 
            
            count -- ; 
            pos ++ ;
            return b&255 ; 
        } 
        else if (count >0) {
            byte b = buf[pos] ; 
            
            count -- ; 
            pos ++ ;
            return b&255 ; 
        }
        return -1 ;
    }
    public void  MyClose() throws IOException {
        in.close() ; 
    }
}

　　上述代码：buf 用来存储从硬盘中读取的数据；其中返回int 型则是对 byte 数据的提升。 因为b 是byte 型，转换成int 型时，前面会自动补1，而为了避免补1，所以与255相& 。

 　  在定义功能方法时，不用使用try ，直接抛出异常。