提要
01 IO流（BufferedWriter）
02 IO流（BufferedReader）
03 IO流（通过缓冲区复制文本文件）
04 IO流（readLine的原理）
05 IO流（MyBufferedReader）
06 IO流（装饰设计模式）
07 IO流（装饰和继承的区别）
01 IO流（BufferedWriter）
字符流的缓冲区
缓冲区的出现提高了对数据的读写效率。
对应类
BufferedWriter
BufferedReader
缓冲区要结合流才可以使用
在流的基础上对流的功能进行了加强
1 /*
2 缓冲区的出现是为了提高流的操作效率，
3 所以在创建缓冲区之前，必须要先有流对象。
4
5 该缓冲区提供了一个跨平台的换行方法 newLine()
6 */
7 import java.io.*;
8 public class BufferedWriterDemo
9 {
10 public static void main(String[] args)throws IOException
11 {
12 //创建一个字符写入流对象
13 FileWriter fw=new FileWriter("buf.txt");
14
15 //为了提高字符写入流效率，加入了缓冲区
16 //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可
17 BufferedWriter bufw=new BufferedWriter(fw);
18
19 for(int x=1;x<5;x++)
20 {
21 bufw.write("abcde"+x);
22 //写入一个行分隔符，是跨平台的
23 bufw.newLine();
24 //记住，只要用到缓冲区，就要记得刷新
25 bufw.flush();
26 }
27
28 //其实，关闭缓冲区，就是在关闭缓冲区流中的对象
29 bufw.close();
30
31
32
33
34 }
35 }
02 IO流（BufferedReader）
1 /*
2 字符读取缓冲区
3 该缓冲区提供了一个一次读一行的方法，readLine（）
4 */
5 import java.io.*;
6 public class BufferedReaderDemo
7 {
8 public static void main(String[] args)throws IOException
9 {
10 //创建一个读取流对象和文件相关连
11 FileReader fr=new FileReader("buf.txt");
12
13 //为了提高效率，加入缓冲技术，
14 //将字符读取流对象作为参数传递给缓冲对象的构造函数
15 BufferedReader bufr=new BufferedReader(fr);
16
17 String line;
18
19 while((line=bufr.readLine())!=null)
20 {
21 System.out.println(line);
22 }
23
24 bufr.close();
25 }
26 }
03 IO流（通过缓冲区复制文本文件）
注意：readLine方法只返回回车符前面的部分，并不返回回车符。
1 /*
2 通过缓冲区复制一个.java文件
3 */
4 import java.io.*;
5 public class CopyTextByBuf
6 {
7 public static void main(String[] args)
8 {
9 BufferedReader bufr=null;
10 BufferedWriter bufw=null;
11
12 try
13 {
14 bufr=new BufferedReader(new FileReader("BufferedWriterDemo.java"));
15 bufw=new BufferedWriter(new FileWriter("buffferWriter_Copy.txt"));
16
17 String line;
18 while((line=bufr.readLine())!=null)
19 {
20 bufw.write(line);
21 bufw.newLine();
22 bufw.flush();
23 }
24 }
25 catch (IOException e)
26 {
27 throw new RuntimeException("读写失败！");
28 }
29 finally
30 {
31 try
32 {
33 if(bufr!=null)
34 bufr.close();
35 }
36 catch (IOException e)
37 {
38 throw new RuntimeException("读取关闭失败！");
39 }
40 try
41 {
42 if(bufw!=null)
43 bufw.close();
44 }
45 catch (IOException e)
46 {
47 throw new RuntimeException("写入关闭失败！");
48 }
49 }
50 }
51 }
04 IO流（readLine的原理）
无论是读一行，或者读取多个字符，其实最终都是在硬盘上一个一个读取，所以最终使用的还是read方法一次一次读取。
05 IO流（MyBufferedReader）
1 /*
2 明白了BufferedReader类中特有方法reaLine的原理后，
3 可以自定义一个类中包含一个功能和readLine一致的方法。
4 来模拟一下BufferedReader
5
6 */
7 import java.io.*;
8 class MyBufferedReader
9 {
10 private FileReader r;
11 MyBufferedReader(FileReader r)
12 {
13 this.r=r;
14 }
15 //可以一次读一行数据的方法
16 public String myReadLine() throws IOException
17 {
18 //定义一个临时容器，原BufferReader封装的是字符数组
19 //为了演示方便，定义一个StringBuilder容器
20 //因为最终还是要将数据变成字符串
21
22 StringBuilder sb=new StringBuilder();
23 int ch=0;
24 while((ch=r.read())!=-1)
25 {
26 if(ch=='
')
27 continue;
28 if(ch=='
')
29 return sb.toString();
30 else
31 sb.append((char)ch);
32 }
33 if(sb.length()!=0)
34 return sb.toString();
35 return null;
36 }
37 public void myClose()throws IOException
38 {
39 r.close();
40 }
41 }
42
43 public class MyBufferedReaderDemo
44 {
45 public static void main(String[] args) throws IOException
46 {
47 FileReader fr=new FileReader("buf.txt");
48
49 MyBufferedReader myBuf=new MyBufferedReader(fr);
50 String line=null;
51 while((line=myBuf.myReadLine())!=null)
52 {
53 System.out.println(line);
54 }
55 myBuf.myClose();
56
57 }
58 }
06 IO流（装饰设计模式）
1 /*
2 装饰设计模式：
3 当想要对已有的对象进行功能增强时，
4 可以定义类，将已有对象传入，基于已有功能，并提供加强功能
5 那么自定义的这个类就成为装饰类
6
7 装饰类通常会通过构造方法接收被装饰的的对象
8 并基于被装饰对象的功能，提供更强的功能
9 */
10 class Person
11 {
12 public void chiFan()
13 {
14 System.out.println("吃饭");
15 }
16 }
17 class SuperPerson
18 {
19 private Person p;
20 public SuperPerson(Person p)
21 {
22 this.p=p;
23 }
24 public void superChiFan()
25 {
26 System.out.println("开胃酒");
27 p.chiFan();
28 System.out.println("甜点");
29 System.out.println("来一根");
30
31 }
32 }
33 public class PersonDemo
34 {
35 public static void main(String[] args)
36 {
37 SuperPerson sp=new SuperPerson(new Person());
38 sp.superChiFan();
39
40 }
41 }
07 IO流（装饰和继承的区别）
用继承体系来实现功能增强
MyReader//专门用于读取数据的类
|--MyTextReader
|--MyBufferTextReader
|--MyMediaTextReader
|--MyBufferMediaReader
|--MyDataReader
|--MyBufferDataReader
class MyBufferReader
{
MyBufferReader(MyTextReader text)
{}
MyBufferReader(MyMediaTextReader media text)
{}
}
上面这个类的扩展性很差
找到其参数的共同类型，通过多态的形式，可以提高扩展性
class MyBufferReader extends MyReader
{
MyBufferReader(MyReader r)
{}
}
用装饰来实现功能增强
MyReader//专门用于读取数据的类
|--MyTextReader
|--MyMediaReader
|--MyDataReader
|--MyBufferReader
装饰模式比继承要灵活，避免了继承体系的臃肿
而且降低了类与类之间的关系。
装饰类因为增强已有对象，具备的功能和已有对象是相同的，
只不过是提供了更强的功能
所以装饰类和被装饰类通常是属于一个体系的