装饰者模式

public class MyBufferedReader extends Reader {

    // 私有一个子类
    private Reader in;

    // 建立一个缓冲区
    private char[] buffer = new char[1024];

    // buffer数组的index
    private int index;

    // buffer数组的实际长度
    private int count;

    public MyBufferedReader(Reader in) {
        super();
        this.in = in;
    }


    /**
     * 书写一个自己的reader方法
     * 每次读取一个字符
     * @throws IOException
     */
    public int myRead() throws IOException {
        if (count == 0) {
            // 从硬盘中读取字节到缓冲数组
            count = in.read(buffer);
            index = 0; // 此时缓冲区数组是一个新的数组，index重置为0
        }

        if (count < 0) {
            return -1;
        }
        // 从缓冲数组中取得读取的字符
        char ch = buffer[index];

        index++; // 每取出一个字节，index下表自增
        count--; // 数组字节数量自减

        return ch;
    }

    public String myReaderLine() throws IOException {
        /**
         * 每次读取到‘\n‘说明读取到了一行，就返回sb
         */
        StringBuilder sb = new StringBuilder();
        int ch;
        while ((ch= myRead()) != -1) {

            if (ch == ‘\r‘) {
                continue;
            }
            if (ch == ‘\n‘) {
                return sb.toString();
            }
            sb.append((char) ch);
        }
        // 读取最后一行没有换行符，判断长度大于零，返回sb
        if (sb.length() != 0) {
            return sb.toString();
        }

        // 文件读取结束
        return null;
    }

    public void myClose() throws IOException {
        in.close();
    }

    /**
     * 读取可变长度的字符
     * @param cbuf
     * @param off
     * @param len
     * @return
     * @throws IOException
     */
    @Override
    public int read(char[] cbuf, int off, int len) throws IOException {
        return 0;
    }

    @Override
    public void close() throws IOException {

    }
}