Java基础---Java---IO流-----BufferedReader、BufferedWriter、缓冲区、装饰设计模式及和继承的区别

IO流
IO流用来处理设备之间的数据传输
java对数据的操作是过流的方式
流按操作数据分为两种：字节流与字符流
流按流向分为：输入流，输出流。

IO流常用基类
字节流的抽象基类：InputStream OutputStream
字符流的抽象基类：Reader,Writer
由这四个类派生出来的子类名称都是以其父类作为子
类名的后缀。
如InputStream 的子类 FileInpuStream
Reader的子类FileReader

数据的最常见的形式是：文件

字符读取缓冲区：

class BufferedReaderDemo  
{  
    //创建一个读取流对象和文件相关联  
    FileReader fr=new FileReader("buf.txt");  
    //为了提高效率，加入缓冲技术，将字符流取对象作为参数传给缓冲对象的构造函数。  
    //只要是文本文件，都是以行的形式存在的。  
    //readLine返回的是该行的字符串，不包含任何行终止符，如果已经达到流的末尾，则返回null.  
    BufferedReader bufr=new BufferedReader(fr);  
    String line=null;  
    while(line=bufr.readLine()!=null)  
    {  
        System.out.println(line);  
    }  
    bufr.close();  


}  

通过缓冲区复制一个.java文件到.txt文件：

class{  
    public static void main(String[] args){  
    BufferedReader bufr=null;  
    BufferedWriter bufw=null;  
    try{  
        bufr=new BufferedReader(new FileReader("bufferwriteDemo.java"));  
        bufw=new BufferedWriter(new FilerWriter("bufwriter.txt"));  
        String line=null;//是两个流之间的中转站  
        while(line=bufr.readLine()!=null){  
            bufw.write(line);//读取一行  
            bufw.newLine();//记得换行  
            bufw.flush();//清空缓冲区数据  
        }  
    //下面是抛出异常  
    }catch(IOException e){  
        throw new RuntimeException("读取关闭失败");  
    }  
    finally{  
        try{  
          if(bufr!=null)  
          bufr.close();  
        }catch(IOException e){  
            throw new RuntimeException("读取失败");  
        }  
        try{  
          if(bufr!=null)  
          bufr.close();  
        }catch(IOException e){  
            throw new RuntimeException("写入失败");  
        }  
    }  


    }  


} 

readline方法的原理：无论是读一行或者读取多个字符，其实都是在硬盘上一个一个的读取，所以最终使用的还是read方法一次读一个的方法。读到一个字符以后只是把它存到一行里，当读到\r,因为它不读任何终止符，
这个时候，把数组里已经存好的字符返回出来。然后接着往下读。一直到读完。。readline比read方法高效。

做一个MyBufferedReader,自定义一个类中包含一个功能和readLine一致的方法，来模拟一个BufferedReader：

import java.io.*;  
class MyBufferedReader{  
    private FileReader r;  
    MyBufferedReader(FileReader r) throws IOException{//抛出异常，下面就不用try,catch了  
        this.r=r;//实例化  

    }  
    //可以一次读一行数据的方法  
    public String myReadLine(){  
        //定义一个临时容器，原Buffered装的是一个字符数组。定义一个StringBuilder容器，因为最终还是要将数据变成字符串。  
        StringBuilder sb=new StringBuilder();  
        int ch=0;  
        while((ch=r.readLine())!=-1){  
            if(ch=='\r')  
            continue;  
            if(ch=='\n')  
            return sb.toString();  
            else  
            sb.append((char)ch);//在指定元素结尾插入字符  

        }  
        if(sb.length()!=0)  
            return sb.toString();  
        return null;  
    }  


    public void myClose()throws IOException{  
        r.close();//模拟关闭流  
    }  


}  


class MyBufferedReaderDemo{  
    public static void main(String [] args){  
        FileReader fr=new FileReader("buf.txt");  
        MyBufferedReader myBuf=new MyBufferedReader(fr);//  
        String line=null;  
        while((line=myBuf.myReadLine()!=null){  
            System.out.println("line");  

        }  
        myBuf.myClose();  

    }  
}  

装饰者设计模式：
当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能，那么自定义的该类称为装饰类。装饰者通常会通过构造对象方法接收被接收的对象，并基于被装饰的对象的功能。并提供更强的功能。

class Person{  
    public void chifan(){  
        System.out.println("吃饭");  
    }  
}  
class SuperPerson{  
    private Person p;  
    SuperPersonn(Person p){  
        this.p=p;  
    }  
    public void superChifan(){  
        System.out.println("吃甜点");  
        p.chifan();  
        System.out.println("吃饭");  
        System.out.println("打牌");  
    }  
}  


class PersonDemo{  
    public static void main(String [] args){  
        Person p=new Person();  
        //p.chifan();  
        SuperPerson sp=new SuperPerson(p);  
        sp.superChifan();  
    }  
}  

装饰和继承的区别
MyReader//专门用于读取数据的类
继承：
|MyTextReader 文本读取
|MYBufferedTextReader
|MyMediaReader 媒体读取
|MyBufferedMediaReader
|MyDataReader
|MyBufferedDataReader

class MyBufferReader{  
    MyBufferReader(MyTextReader text){  
    }  
    MyBufferReader(MyBufferedMediaReader media){  
    }  

}  

上面这个类的扩展性极差，找到其参数的共同类型，可以提高扩展性

下面这个就是装饰设计模式，可以将这个体系优化
|MyTextReader 文本读取
|MyMediaReader 媒体读取
|MyDataReader
|MyBufferReader
装饰模式比继承要灵活，避免了继承了体系的冗余，而且降低了类与类之间的关系
装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能，所以装饰类和被装饰类通常是都属于一个体系中的。
MyReader//专门读取数据的类

class MyBufferReader{  
    MyBufferReader(MyReader r){  

    }  
}