java第20天----字符缓冲流，字节流，标准输入流，装饰设计模式，适配器设计模式

昨天知识总结

• 1.流的基础
• 2.流的分类
• 3.字符流
  • 读 FileReader
  • 写 FileWriter
• 4.File

流

字符缓冲流

• 字符缓冲流:又叫字符缓冲区，为了提高读写的能力，本身没有读写的能力，要想进行读写，必须依靠字符流来实现。
• 可以将缓冲流比作催化剂或者高速的小车
• 字符缓冲流分类：
  • 1.字符缓冲读入流：BufferedWriter 辅助读，没有读的能力
    

    public static void main(String[] args) throws IOException {
		//1.创建缓冲写入流,并关联写出流
		BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("test.txt"));
		
		//2.写
		bufferedWriter.write("bingbing");
		/*
		 * 换行:优点:有跨平台性
		 */
		bufferedWriter.newLine();
		bufferedWriter.write("bingbing2");
		
		//3.关闭流。a.关闭写出流	b.刷新	c.关闭缓冲写出流
		bufferedWriter.close();
	}

• • 2.字符缓冲写出流：BufferedReader 辅助写，没有写的能力

public static void main(String[] args) throws IOException {
		/*
		 *1.字符缓冲读入流：BufferedReader		辅助读，没有读的功能
		 * 
		 */
		//1.创建字符缓冲读入流的对象
		BufferedReader reader  = new BufferedReader(new FileReader("test.txt"));
		
		//2.读
		//a:一次读一个字符
//		int num;
//		while((num = reader.read())!=-1) {
//			System.out.println((char)num);
//		}
		//b:一次读多个字符
//		int num;
//		char[] arr = new char[4];
//		while((num= reader.read(arr))!=-1) {
//			System.out.println(new String(arr,0,num));
//		}
		//c.一次读一行-readLine（）
		//特点：不会将当前的换行符返回，返回值就是我们读到的内容，以字符串的形式返回，当返回null的时候，就读完了
		String data = null;
		while((data = reader.readLine())!=null) {
			System.out.print(data);
			System.out.println();//打印控制台时候使用的换行符
		}
		
		//3.关闭流
		reader.close();
	}

LineNumberReader

• LineNumberReader:是BufferedReader的子类，不能读，但是可以提高效率，，其他功能：设置行号，获取行号

    public static void main(String[] args) throws IOException {
		
		//1.创建缓冲流
		LineNumberReader lineNumberReader = new LineNumberReader(new FileReader("src\\com\\qianfeng\\test\\Demo2.java"));
		
		//设置行号：
		//注意点：默认从0 开始设置，从1开始计数
		lineNumberReader.setLineNumber(0);
		
		//2.读
		String data = null;
		while((data = lineNumberReader.readLine())!= null) {
			System.out.print(lineNumberReader.getLineNumber());//获取行号
			System.out.print(data);
			System.out.println();
		}
		//3.关闭流
		lineNumberReader.close();
	}

字节流

• 字符流：传输的是字节，只能用于字符的传输
  • 字符读入流：Reader
    • read（） reader(数组)
  • 字符写出流：Writer
    • writer（int c） writer（char（） arr） writer（String s）
  • 缓冲字符读入流BufferedReader
    • readLine（）
  • 缓冲字符写出流BufferedWriter
    • newLine（）
• 字节流：传输的是字节，可以传输所有内容
  • 字节输入流InputStream
  • 字节输出流OutputStream
  • 缓冲字节输入流：BufferedInputStream
  • 缓冲字节输出流：BufferedOutputStream

//写
	public static void writerFile() throws IOException {
		OutputStream outputStream = new FileOutputStream("temp2.txt");
		outputStream.write("bingbing".getBytes());//使用默认的格式编码
		outputStream.close();
	}
	//读1--一次一个字节
	public static void readerFile1() throws IOException {
		InputStream inputStream = new FileInputStream("temp2.txt");
		int num;
		while((num = inputStream.read())!=-1) {
			System.out.println((char)num);
		}
		inputStream.close();
	}
	//读2----一次读多个字节
	public static void readFile2() throws IOException {
		InputStream inputStream = new FileInputStream("temp2.txt");
		int num;
		byte[] arr = new byte[4];
		while((num = inputStream.read())!=-1) {
			System.out.println(new String(arr,0,num));
		}
		inputStream.close();
	}
	//读3---一次全部读出
	public static void readFile3() throws IOException {
		InputStream inputStream = new FileInputStream("temp2.txt");
		//获取的所有字节数
		//如果文本的字节数过大，不建议使用
		int nums = inputStream.available();
		byte[] arr = new byte[nums];
		int num = inputStream.read(arr);
		//while((num = inputStream.read())!=-1) {
		System.out.println(new String(arr,0,num));
		//}
		inputStream.close();
	}

标准输入流

• 标准输入流:System.in.:此流已经被打开，这个流默认对应键盘(输入源)或由主机或由用户提供的输入源

public static void main(String[] args) throws IOException {
		//标准输入流	输入源：键盘	中转点：内存	输出源：控制台
		InputStream inputStream = System.in;//这个流已经默认绑定了键盘，所以可以之际从键盘接受数据，这个是字节流
		
//		int num = inputStream.read();//是一个阻塞式方法，会一直等待用户输入
//		System.out.println(num);
		
		/*
		 * 实例：要求可以从键盘不断地接受字节，
		 * 一行一行的接收
		 */
		myReadLine(inputStream);
	}
	public static void myReadLine(InputStream inputStream) throws IOException {
		StringBuffer buffer = new StringBuffer();
		while(true) {
			int num = inputStream.read();
			if(num == '\r') {
				continue;
			}else if(num == '\n') {
				System.out.println(buffer.toString());
				//当输入over的时候认为是结束
				if(buffer.toString().equals("over")) {
					break;
				}
				buffer.delete(0, buffer.length());
			}else {
				buffer.append((char)num);
			}
			
		}
	}

装饰设计模式

• 装饰设计模式：基于已经实现的功能，提供增强的功能
• 装饰设计模式的由来就来自于对缓冲流的实现
• 特点：从缓冲流的角度讲解
  • 1.使流原来的继承体更加的简单
  • 2.提高了效率
  • 3.由于是在原有的基础上提高了增强的功能，所以他还要属于原来的体系
• 演示：如果自己设计装饰设计模式，怎么处理？
  • 1.原来的类：Test
  • 2.装饰类：Btest
• 步骤：
  • 1.让BTest继承自Test
  • 2.在BTest内有一个Test类型的成员变量
  • 3.通过BTest内一个带参数的构造方法接收外部传入的一个Test类型的对象，交给内部的Test的属性
  • 4.实现功能的时候，调用传入的Test类型的对象实现原有的功能，自己实现增强的功能
• 实现BufferedReader的重写
• 分析：
  • 1.要属于流的体系
  • 2.要有一个Reader类型的成员变量
  • 3.要有一个带参数的方法接受外部的流对象
  • 4.模拟readLine（）方法，实现度一行的功能
  • 5.重写close（）方法

//1.要属于流的体系
class MyBufferReader extends Reader{
	// 2.要有一个Reader类型的成员变量
	Reader reader;
	//3.要有一个带参数的方法接受外部的流对象
	public MyBufferReader(Reader reader) {
		// TODO Auto-generated constructor stub
		this.reader = reader;
	}
	
	//4.模拟readLine（）方法，实现度一行的功能
	public String readLine() throws IOException {
		//a:准备一个临时的可变字符串，存储当前行的内容
		StringBuffer str = new StringBuffer();
		//b:开始读
		int data;					
		while((data = reader.read())!=-1) {
			if(data=='\n') {//停止读
				return str.toString();
			}else if(data == '\r') {//继续读
				continue;	
			}else {
				str.append((char)data);
			}
		}
		//c.当文本没有内容是的处理
		if(str.length()==0) {
			return null;
		}
		//d：当文本只有一行，没有换行符
		return str.toString();
		//e：这里写提高效率的代码
	}
	
	
	
	
	
	@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
		//关闭读入流
		this.reader.close();
		//将自己关闭
		//this.close();
	}
	
}

适配器设计模式

• 适配器设计模式：通常可以变相的理解成装饰设计模式
• 实例：要求在子类中只是用play方法
• 分析：Dog是继承了ZiMidel类，ZiMidel类是想了Inter接口
• 当Dog类想要实现Inter接口的一个方法的时候，如果直接实现Inter接口，就必须将所有的方法都实现。
• 如果在Dog类与Inter接口之间插入一个可，让这个类去实现Inter接口的所有方法，作为这个类的子类只需要实现自己需要的方法
• 我们将中间的这个类成为适配器类

interface Inter{
	public void play();
	public void song();
	public void run();
	public void eat();
	public void jump();
}
//适配器类
class ZiMidel implements Inter{

	@Override
	public void play() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void song() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void jump() {
		// TODO Auto-generated method stub
		
	}
	
}


//创建狗类,我只想让她实现play方法?
class Dog extends ZiMidel{
	public void play() {
		// TODO Auto-generated method stub
		
	}
}

class Cat extends ZiMidel{
	public void song() {
		
	}
}