Day 17：缓冲输出字符流和用缓冲输入输出实现登录、装饰者设计模式

输出字符流
　　Writer  所有输出字符流的基类，  抽象类。
　　　　FileWriter 向文件输出字符数据的输出字符流。
　　　　　　BufferedWriter 缓冲输出字符流        缓冲输出字符流作用： 提高FileWriter的写数据效率与拓展FileWriter的功能。
　　　　　　BufferedWriter内部只不过是提供了一个8192长度的字符数组作为缓冲区而已，拓展了FileWriter的功能。

BufferedWriter如何使用？
 1. 找到目标文件
  2. 建立数据的输出通道

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class Demo1 {
    public static void main(String[] args) throws IOException {
        File file = new File("F:\a.txt");
        FileWriter fw = new FileWriter(file);
        BufferedWriter bw = new BufferedWriter(fw);
        String a = "fdsfdsfgdsgdsgs";
        bw.write(a);
        bw.flush();
        
        
    }
}

练习： 缓冲输入输出字符流用户登陆注册

　　　（以文件的形式保存了用户信息）

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

public class Demo2 {
    static Scanner s = new Scanner(System.in);
    public static void main(String[] args) throws IOException {
        
        while(true) {
            System.out.println("请选择功能： A:(注册)   B:(登陆)");
            String b = s.next();
            if(b.equalsIgnoreCase("a")) {
                zuce();
            }else if(b.equalsIgnoreCase("b")) {
                denglu();
            }else {
                System.out.println("输入错误！请重新检查输入。。。。。。");
            }
        }
    }

    private static void denglu() throws IOException {
        // TODO Auto-generated method stub
        System.out.println("请输入用户名：");
        String name = s.next();
        System.out.println("请输入密码：");
        String password = s.next();
        String jilu = name+" "+password;
        BufferedReader bw = new BufferedReader(new FileReader("F:\users.txt"));
        String content = null;
        while((content = bw.readLine())!=null) {
            if(jilu.equals(content)) {
                System.out.println("欢迎"+userName+"登陆成功...");
                break;
            }
        }
    }

    private static void zuce() throws IOException {
        // TODO Auto-generated method stub
         System.out.println("请输入用户名：");
            String userName = s.next();
            System.out.println("请 输入密码：");
            String password = s.next();
            String info = userName+" "+ password;
            File file = new File("F:\users.txt");
            FileWriter fileWriter = new FileWriter(file,true);
            BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
            bufferedWriter.write(info);
            bufferedWriter.newLine();
            bufferedWriter.close();
    }
}

//缺点：没有设置不可重复注册同一用户名

//优点：集合方法实现的程序退出后账户信息就没了，该程序将用户信息以记录的形式保存了下来

//升级：后期可以加上GUI将其做成登陆窗口

 

 装饰者设计模式：增强一个类的功能，而且还可以让这些装饰类互相装饰。
 
 BufferedReader是不是拓展了FileReader的功能。
 BuferedWriter 也是拓展了FileWriter的功能。
 
 需求1： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有行号。
 
 需求2：编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有分号。
 
 需求3： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有双引号。

Reader
　　BufferedReader
　　　　BufferedLineNum  带行号
　　　　BufferedSemi    带分号
　　　　BufferedQuto   带双引
　　　　子类..

增强一个类的功能时候我们可以选择使用继承：
 
通过继承实现增强一个类的功能优点：   代码结构清晰，通俗易懂。
 
缺点： 使用不灵活，会导致继承的体系过于庞大。
 

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

//带行号的缓冲输入字符流
class BufferedLineNum extends BufferedReader{
    int count = 1 ;

    public BufferedLineNum(Reader in) {
        super(in);
    }
    
    @Override
    public String readLine() throws IOException {
        String line = super.readLine(); 
        if(line ==null){
            return null;
        }
        line = count+" "+ line;
        count++;
        return line;
    }    
}

//带分号的缓冲输入字符流
class BufferedSemi extends BufferedReader{

    public BufferedSemi(Reader in) {
        super(in);
    }
    
    @Override
    public String readLine() throws IOException {
        String line =  super.readLine();
        if(line==null){
            return null;
        }
        line = line+";";
        return line;
    }
}

//带双引号的缓冲输入字符流
class  BufferedQuto extends BufferedReader{

    public BufferedQuto(Reader in) {
        super(in);
    }
    
    @Override
    public String readLine() throws IOException {
        String line = super.readLine();
        if(line==null){
            return null;
        }
        line = """+line+""";
        return line;
    }
}


public class Demo3 {

    public static void main(String[] args) throws IOException {
        File file = new File("F:\Demo1.java");

        FileReader fileReader = new FileReader(file);

        BufferedLineNum bufferedLineNum = new BufferedLineNum(fileReader);

        BufferedSemi bufferedSemi = new BufferedSemi(fileReader);
        
        BufferedQuto bufferedQuto = new BufferedQuto(fileReader);
        
        String line = null;
        while((line = bufferedQuto.readLine())!=null){
            System.out.println(line);
        }
    }
}

 装饰者设计模式：增强一个类的功能，而且还可以让这些装饰类互相装饰。

装饰者设计模式的步骤：
 1. 在装饰类的内部维护一个被装饰类的引用。
 2. 让装饰类有一个共同的父类或者是父接口。

　　继承实现的增强类和修饰模式实现的增强类有何区别？

 　　　　继承实现的增强类：
  　　　　　　优点：代码结构清晰，而且实现简单.
 　　　　　　 缺点：对于每一个的需要增强的类都要创建具体的子类来帮助其增强，这样会导致继承体系过于庞大。

　　　　修饰模式实现的增强类：
  　　　　　　优点：内部可以通过多态技术对多个需要增强的类进行增强， 可以是这些装饰类达到互相装饰的效果。使用比较灵活。
  　　　　　　缺点：需要内部通过多态技术维护需要被增强的类的实例。进而使得代码稍微复杂。

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
//带行号的缓冲输入字符流
class BufferedLineNum2  extends BufferedReader{  
    
    BufferedReader bufferedReader;
    int count = 1;
    public BufferedLineNum2(BufferedReader bufferedReader){
        super(bufferedReader);// 注意： 该语句没有任何的作用，只不过是为了让代码不报错。
        this.bufferedReader = bufferedReader;
    }
    
    public String readLine() throws IOException{
        String line = bufferedReader.readLine();
        if(line==null){
            return null;
        }
        line = count+" "+line;
        count++;
        return line;
    }
} 

//带分号缓冲输入字符流
class BufferedSemi2 extends BufferedReader{ 

    BufferedReader bufferedReader;

    public BufferedSemi2(BufferedReader bufferedReader){
        super(bufferedReader);
        this.bufferedReader = bufferedReader;
    }
    
    public String readLine() throws IOException{
        String line = bufferedReader.readLine(); 
        if(line==null){
            return null;
        }
        line = line +";";
        return line;
    }
}

//缓冲类带双引号
class BufferedQuto2 extends BufferedReader{
    
    BufferedReader bufferedReader;
    
    public BufferedQuto2(BufferedReader bufferedReader){ 
        super(bufferedReader) ; 
        this.bufferedReader = bufferedReader;
    }
    
    public String readLine() throws IOException{
        String line = bufferedReader.readLine();  
        if(line==null){
            return null;
        }
        line = """+line +""";
        return line;
    }
}

public class Demo4 {
    
    public static void main(String[] args) throws IOException {
        File file = new File("F:\Demo1.java");
        FileReader fileReader = new FileReader(file);
        //建立缓冲输入字符流
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        //建立带行号的缓冲输入字符流
        BufferedLineNum2 bufferedLineNum = new BufferedLineNum2(bufferedReader);
        //带分号的缓冲输入字符流
        BufferedSemi2 bufferedSemi2 = new BufferedSemi2(bufferedLineNum);
        //带双引号的缓冲输入字符流
        BufferedQuto2 bufferedQuto2 = new  BufferedQuto2(bufferedSemi2);
        
        String line = null;
        while((line = bufferedQuto2.readLine())!=null){
            System.out.println(line);
        }    
    }
}