IO流（装饰设计模式）

package com.yyq;
/* 装饰设计模式：就是将被修饰的部分当作参数传递给修饰的类：
 * （当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能，那么自定义的类
 * 称为装饰类）
 * 装饰类：通常会通过构造方法接受被装饰的对象,并给予被装饰对象的功能,提供更强的功能
 * 
 * 装饰和继承的区别:  
 *       设计类的发展历程: 
 *          MyReader : 专门用于读取数据的类
 *          数据有很多种 : 所以有多中读取方式: 
 *          |--MyTextReader 
 *               |-- myBufferTextReader
 *          |--MyMediaReader出现了继承体系
 *               |-- myBufferMediaReader
 *          又来了一种数据类型
 *          |--myDataReader
 *               |-- MyBufferDataReader
 *          臃肿，需要进行优化， 扩展出来的子类都是用的 缓冲技术，
 *    class MyBufferedReader{
 *        // 定于一个缓冲区： 谁需要缓冲区，把它传递进来，谁需要，就传递进来将它进行增强。
 *        MyBufferDataReader(){}
 *        myBufferMediaReader()){}
 *        
 *    }
 *    上面这个类扩展性很差，找到其参数的功能类型，通过多态的形式，可以提高其扩展性
 *    class myBufferedReader MyReader{
 *            //更强的读，既然都是读的话，所以是读的子类
 *            MyBufferReader(MyReader r){
 *        {
 *    }
 *         |--MyTextReader 
 *              ( |-- myBufferTextReader)
 *         |--MyMediaReader出现了继承体系
 *              ( |-- myBufferMediaReader)
 *          又来了一种数据类型
 *         |--myDataReader
 *              ( |-- MyBufferDataReader)
 *         |--MyBufferReader(优化后的体系，设计模式：为优化而生
 *         )
 * 
 * 装饰模式比继承要灵活，避免了继承体系的臃肿 而且降低了类与类之间的关系
 * 装饰类因为是增强已有对象，具备的功能和已有的是相同的
 * 只不过提供了更强的功能，所以装饰类和被装饰类是一个体系中
 * 由继承结构变成了组合结构
 * 
 * 
 * readLine 方法的原理
 * 无论是读一行，获取读取多个字符其实最终都是在硬盘上一个一个的读取，所以最终使用的都是
 * read方法一次读一个的发法
 * 缓冲区：带数组的内存 readline 底层用的是read方法
 *readline 使用一个数组把数据临时存储起来了，档遇到换行时把数据返回出来
 */
/*
 * 明白了BufferedReader 类中特有的方法readline
 * 可以自定义一个类包含功能myreadline 来模拟bufferedreader、
 * 自己定义一个自己的myBufferedReader
 */
import java.io.*;
class Person
{
    public void chifan(){
        System.out.println("吃饭");
    }
}
class SuperPerson{
    Person p;
    SuperPerson(Person p){
        this.p = p;
    }
    public void superChifan(){
        System.out.println("好好吃");
    }
}
/*
 * 覆盖Reader中的方法
 */
class MyBufferedReader extends Reader{
    // 可以一次读取一行的方法
    
    Reader fr = null;
    MyBufferedReader(Reader fr){
        this.fr = fr;
    }
    public String myReadLine() throws IOException{
        //定义一个临时容器，源bufferedReader 封装的是字符数组
        //为了演示方便，定义StringBuilder 容器，最终将数据变成字符串
        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(){
        try{
            fr.close();
        }
        catch(IOException e){
            e.printStackTrace();
        }
    }
    @Override
    public int read(char[] cbuf, int off, int len) throws IOException {
        // TODO Auto-generated method stub
        return 0;
    }
    @Override
    public void close() throws IOException {
        // TODO Auto-generated method stub
        
    }
}
public class ReadLineDemo {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        Person p = new Person();
        p.chifan();
        /*MyBufferedReader mybufr = new MyBufferedReader(new FileReader("1.txt"));
        String line = null;
        while((line = mybufr.myReadLine())!=null){
            System.out.println(line);
        }*/
    }

}