装饰者模式及打印流

```
装饰者模式（设计模式）
思想 可以通过装饰对原来的功能进行升级

例如 BufferoutStream (outputstream out )

fileoutputstream 是被装饰者

装饰者模式流程
1.把被装饰者写成成员变量
2.构造方法中给该成员变量赋值
3.对原有的功能进行升级

好处：
高内聚：类中的方法之间的联系 最好紧密
低耦合：类与类之间最好不要有联系

interface coder{
    public abstract void study();
}

// 学生是被装饰者
class Student implements Coder {
    // 在学校进行学习
    public void code() {
        System.out.println("c语言");
        System.out.println("c++");

    }

}



class lanxiangStudent implements Coder {
    private Student student;
构造方法中传入 被装饰者
构造方法就是初始化成员变量
所以被装饰者就应该是本类的成员变量

    public lanouStudent() {
        super();
        // TODO Auto-generated constructor stub
    }

    public lanouStudent(Student student) {
        super();
        this.student = student;
    }

    // 在蓝翔进行学习
    public void code() {
        // 被装饰者的功能
        student.code();
        // 功能升级
        System.out.println("会开挖掘机");
    }

}

例：利用装饰者模式实现LinenumberReader（带行号）
被装饰者是 Reader

public class demo04 {
    public static void main(String[] args) throws IOException {
        FileReader fReader =new FileReader("/Users/lanou/Desktop/test/haha.txt");
        wzwLineNumberReader wzw = new wzwLineNumberReader(fReader);
        String string ="";
        wzw.setNum(0);
        while((string = wzw.myread())!=null) {
            System.out.println(wzw.getNum()+":"+string);
        }
      wzw.closemyread();
    }
}

class wzwLineNumberReader {
    private Reader reader;
    private int num = 0;

    public wzwLineNumberReader() {
        super();
        // TODO Auto-generated constructor stub
    }

    public wzwLineNumberReader(Reader reader) {
        super();
        this.reader = reader;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String myread() throws IOException {
        num++;
        StringBuilder sb = new StringBuilder();
        int len = 0;
        while ((len = reader.read()) != -1) {
            if (len == '\n') {
                return sb.toString();
            } else {
                // 不换行就拼接
                sb.append((char) len);
            }


        }
        if (sb.length() == 0) {
            return null;
        }
        return sb.toString();
    }
public void closemyread() throws IOException {
    reader.close();
}
}


首先 将Reader作为成员变量，在构造方法中初始化成员变量，然后对其进行包装，定义一个StringBuffer sb 来拼接字符串，
然后用Reader的方法一个一个读字符，如果读出来的字符为换行，则表示这一行读完了，就把sb.tostring返回，如果不是换行，就用append拼接字符窜，最后进行判断sb.length()是否为空，如果空说明，读完换行后后面没有字符 了已经，所以返回一个空

把num定义成成员变量赋值为0；然后myread方法每运行一次就加一，实现设置行号


打印流（只能输出）
PrintStream 输出字符
PrintWriter 输出字节
1.只能作为数据的目的地
2.可以把数据原样输出
3.永远不会有IO异常，但是会抛出其他异常，比如 空指针

4.打印流相当于 把可以其他的流对象装饰了一个原样输出的功能


字节写入
private static void fun1() throws FileNotFoundException {
        File file = new File("/Users/lanou/Desktop/test/haha.txt");
        FileOutputStream fos = new FileOutputStream(file);
        //创建缓冲字节输出流
        BufferedOutputStream bos =new BufferedOutputStream(fos);        
        PrintStream ps =new PrintStream(bos);
        //写数据
        ps.println("万志伟");
        ps.println(true);
        ps.println(100);
        ps.println(3.14);
        ps.write(100);
        ps.print('p');
        //关闭资源
        ps.close();
    }

字符写入

private static void fun2() throws FileNotFoundException {
        //打印字符流
        File file = new File("/Users/lanou/Desktop/test/haha.txt");
        PrintWriter printWriter =new PrintWriter(file);
        printWriter.print("hahahh\n");
        printWriter.print(200);
        printWriter.print(false);
        printWriter.flush();
        printWriter.close();
    }

注意；字符写入要刷新。


public static void main(String[] args) throws IOException {
        System.out.println("请输入");
        //读取从键盘输入的数据
        //当我输入quit的时候程序停止
        InputStream in = System.in;
        int len = 0;
        StringBuilder sb = new StringBuilder();
        while(true) {
            if(sb.toString().endsWith("quit")) {
                break;
            }
            //读取数据
            len = in.read();
            if(len =='\n') {
                System.out.println(sb.toString());
                //清空缓冲字符串
            sb.delete(0, sb.length());
            }else {
                sb.append((char)len);
            }
        }