java基础12【File、路径、IO流、装饰者模式、字符流、字节流、转换流、系统流、打印流】

java基础12

文件 - File

代表文件或者目录（文件夹）的类。

• 练习：删除目录
  思路：写一个单独的方法来删除目录或者文件：判断是一个目录还是还是一个文件；如果是文件(isFile())直接删除(delete())，如果是目录(isDirectory())，获取这个目录下的所有的子目录和子文件(listFiles()) — 后续功能和当前方法要完成的事情是一致的，所以使用递归

package cn.tedu.map;

import java.io.File;
import java.io.IOException;

public class FileExer {
	
	public static void main(String[] args) throws IOException {
		
		File file = new File("D:\\a\\c.java");
		
//		boolean b = file.mkdirs();
		
//		boolean a = file.createNewFile();
		
		delDir(file);
	}
	public static void delDir (File file){
		
		 if(file.isDirectory()){
			File[] fs = file.listFiles();
			for(File f : fs)
				delDir(f);		
		 }
		 file.delete();
	}
	public static void del(File file) {

		// 判断参数是否为空
		if (file == null)
			throw new NullPointerException("亲，文件不能为空哦~~~");

		// 判断file对象是文件还是目录
		if (file.isDirectory()) {

			// 如果是目录，需要获取这个目录下的所有的子文件和子目录
			File[] fs = file.listFiles();
			for (File f : fs) {
				// 逐个遍历每一个元素，判断这个元素是文件还是目录
				del(f);
			}

		}

		// 无论是文件还是目录都需要删除
		file.delete();
	}

	

}

目录

• 练习：统计工作空间中Java文件和class文件的个数
  思路：定义一个新的方法进行统计：先获取工作空间中所有的子文件和子目录。如果是子目录—递归；如果子文件，需要判断这个文件是否是一个Java文件还是一个class文件

package cn.tedu.file;

import java.io.File;

public class FileExer2 {

	static int javaCount = 0;
	static int classCount = 0;

	public static void main(String[] args) {

		File file = new File("C:\\Users\\Administrator\\Desktop\\笔记\\老师笔记");
		count(file);

		System.out.println(javaCount);
		System.out.println(classCount);

	}

	public static void count(File file) {

		// 判断file对象是否为空
		if (file == null)
			throw new NullPointerException();

		// 判断是否是一个目录
		if (file.isDirectory()) {
			// 获取这个目录下的所有的子文件和子目录
			File[] fs = file.listFiles();
			for (File f : fs) {
				count(f);
			}
		} /* file如果不是目录就是文件 */ else if (file.getName().endsWith(".java"))
			javaCount++;
		else if (file.getName().endsWith(".class"))
			classCount++;

	}

}

File - 知识点

目录,再往上一拉

// 表示创建了一个代表D盘下a.txt的File对象
		// file对象创建的时候并不会去计算机中检查文件是否真实存在
		// 只是将传入的路径标记为了一个file对象
		File file = new File("D:\\test");

		// 删除文件/目录 --- 不可逆
		// 表示将文件/目录从计算机中彻底移除，不可撤销
		// 在删除目录的时候要求目录是空目录
		boolean b = file.delete();

		// 创建文件
		// 如果这个文件不存在，则创建该文件
		// 如果文件已经存在，则创建失败
		// 在创建这个文件的时候要求这个文件的存放路径必须真实存在
		// 只能创建文件不能创建目录
		// boolean b = file.createNewFile();

		// 创建目录
		// make directory
		// 当且仅当这个目录不存在的时候才会创建
		// 只能创建一层目录
		// boolean b = file.mkdir();
		// 表示可以创建一层或者多层目录
		// boolean b = file.mkdirs();

		System.out.println(b);

		File file = new File("E:\\");
		// 获取E盘下的所有的子目录和子文件
		File[] fs = file.listFiles();
		for (File f : fs) {
			// 获取文件的名字
			System.out.println(f.getName());
		}

		// 判断file对象是否是一个目录
		System.out.println(file.isDirectory());
		// 判断file对象是否是一个文件
		System.out.println(file.isFile());

		File file = new File("D:\\a");
		// 判断file所代表的文件或者目录是否真实存在
		System.out.println(file.exists());
		
		// 判断是否可写
		System.out.println(file.canWrite());
		
		// 判断是否是一个隐藏文件
		System.out.println(file.isHidden());
		
		// 判断是不是一个绝对路径
		System.out.println(file.isAbsolute());

		File file = new File("D:\\a.txt");
		// 获取文件的修改时间,也就是文件第一次创建时间，也是最后一次修改时间
		System.out.println(file.lastModified());
		// 设置文件的最后一次修改时间，要比文件的修改时间大。
		// file.setLastModified(74617964131L);

		// 设置文件是否可执行
		// System.out.println(file.setExecutable(false));
		// 设置文件是否可读
		// System.out.println(file.setReadable(false));
		// 设置文件是否可写
		// System.out.println(file.setWritable(false));

目录,再往上一拉

package cn.tedu.file;

import java.io.File;
import java.io.IOException;

public class FileDemo5 {

	public static void main(String[] args) throws IOException {

//		File file = new File(/*"D:" + File.separatorChar + "a" + File.separatorChar + */"aaa.txt");
		// 在Windows中，分隔目录用的\
		// 在Linux中，分隔目录用的/
		// 在Windows中，分隔路径用的;
		// 在Linux中，分隔路径用的:
//		File file = new File(/*"D:" + File.separatorChar + "a" + File.separatorChar + */"aaa.txt");
//		File file = new File("a/aaa.txt");
		File file = new File("aaa.txt");

//		boolean a = file.mkdirs();
//		boolean b = file.createNewFile();
		
		// 获取父路径  从斜杠的位置往前截。不管文件是否真实存在，只看传入的路径（参数）。
		System.out.println(file.getParent());
//		获取文件名  从斜杠的位置往后截。不管文件是否真实存在，只看传入的路径（参数）。
		System.out.println(file.getName());

		// 获取绝对路径
		 System.out.println(file.getAbsolutePath());
		// 获取路径（文件名）
		 System.out.println(file.getPath());

	}

}

目录,再往上一拉

package cn.tedu.file;

import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;

public class FileDemo6 {

	public static void main(String[] args) {

		File file = new File("D:\\");

		// 获取指定目录下的所有的子目录和子文件
		// File[] fs = file.listFiles();

		// 获取E盘下所有的子文件
//		 File[] fs = file.listFiles(new FileFilter() {
//		
//		 @Override
//		 // 写过滤规则
//		 // 过滤之后如果返回true，则自动放入数组中
//		 public boolean accept(File pathname) {
//		 return pathname.isFile();
//		 }
//		 });
		// 获取E盘下名字中含有数字的子文件或者是子目录
		// File[] fs = file.listFiles(new FileFilter() {
		//
		// @Override
		// public boolean accept(File pathname) {
		// return pathname.getName().matches(".*\\d.*");
		// }
		// });
		File[] fs = file.listFiles(new FilenameFilter() {

			@Override
			// dir表示文件所存储的路径
			public boolean accept(File dir, String name) {
				return name.matches(".*\\d.*");
			}
		});

		for (File f : fs) {
			System.out.println(f);
		}

		// 获取内存空间 --- 返回的是字节个数
		// long count = file.getTotalSpace();
		// System.out.println(count);

		// 获取可以使用的空间大小
		// System.out.println(file.getUsableSpace());

	}

}

目录,再往上一拉

		File file = new File("E:\\b.txt");
		// 将文件重命名b.txt
		// file.renameTo(new File(file.getParent(),"b.txt"));
		// file.renameTo(new File("D:\\b.txt"));
		// 路径改变的前提下做的是剪切操作
		// file.renameTo(new File("E:\\b.txt"));

		file.renameTo(new File("D:\\a.txt"));

路径

绝对路径：以盘符或者/开头的路径。指定的位置和文件当前所处的位置没有任何关系
相对路径：不以盘符或者/开头的路径。以当前路径为基准来计算指定的文件的所在路径

IO流

• 用于数据的传输的机制。File不能操作文件内容，所以引入IO。
• IO -> Input Output Stream -> 输入输出流。
  可以利用输入输出流向程序中写入写出数据。其中传输的是数据的流。
  按照数据流流动的方向，流分为输入流 和 输出流。流的方向由程序的角度来思考，将数据写入程序的流称之为输入流，从程序中写出数据的流，称之为输出流。
• 根据数据传输方向：输入流和输出流
  根据数据传输形式：字符流和字节流
  
  这四大基本流是流的继承结构的根，都是抽象类，无法直接使用，一般用的都是他们的具有具体功能的子孙类。
• 数据的来源/目的地：存储设备、物理设备、内存、网络

向一个TXT文件中写入字符串 -> 输出流、字符流、和文件相关的流 -> FileWriter

流中的异常处理

• 将流对象放在try之外声明并且赋值为null；放到try之内进行初始化
• 在关流之前需要判断流对象是否为空
• 为了防止关流失败导致流依然占用文件，所以需要将流对象强制置为null
• 为了防止关流的时候自动冲刷缓冲区失败导致一部分数据产生丢失，需要在关流之前进行一次手动的冲刷

目录,再往上一拉

字符流

• 字符输入流Reader - FileReader
  构造方法：
  FileReader(File file)
  FileReader(String fileName)
  读取数据的方法：
  int read()
  int read(char[] cbuf)
  关闭流：
  close()
  
  为什么read方法返回的不是char而是Int？
  因为read如果返回的是char，则无法用任意的char表示到达了文件的结尾，所以此处不返回char 而是返回int，正常情况下返回的是正数，强转为char即可得到对应字符，而当读取到文件结尾返回-1表示

• 字符输出流Writer - FileWriter
  构造方法：
  FileWriter(File file)
  FileWriter(String fileName)
  输出数据的方法：
  void write(int c)
  write(char[] cbuf)
  刷新流：
  flush()
  关闭流：
  close()

   案例：利用字符流来复制文件
   案例：利用带有自定义缓冲的流来复制文件提高效率
  

  目录,再往上一拉

  缓冲流

  java.io.BufferedReader
  构造方法:
  BufferedReader(Reader in)
  BufferedReader(Reader in, int sz)
  将一个Reader传入BufferedReader后 BufferedReader会在原来Reader的基础上增加缓冲区，从而实现高效的读取数据，这个过程中BufferedReader不会改变原有Reader的功能，只是为底层的流提供了缓冲的能力，用来提高读取效率。
  方法:
  int read()
  int read(char[] cbuf)
  int read(char[] cbuf, int off, int len)
  String readLine()
  close()
  java.io.BufferedWriter
  构造方法:
  BufferedWriter(Writer out)
  BufferedWriter(Writer out, int sz)
  将一个Writer传入BufferedWriter后 BufferedWriter会在原来Writer的基础上增加缓冲区，从而实现高效的写出数据，这个过程中BufferedWriter不会改变原有Writer的功能，只是为底层的流提供了缓冲的能力，用来提高写出效率。
  方法:
  write(int c)
  write(String str)
  write(char[] cbuf)
  write(char[] cbuf, int off, int len)
  newLine()

  装饰设计模式

目录,再往上一拉

• 设计模式
  前人对编写java代码的套路的总结，java一共有23种通用设计模式。
  装饰设计模式主要的能力，是通过装饰者包装被装饰者，在被装饰者原有的功能的基础上，增加额外的能力。
  装饰设计模式实现方式：
  写一个类 使其具有和被装饰者相同的方法
  提供构造方法 将被装饰者 传入保存在类的内部
  对于不想改造的方法直接调用原有对象本来的方法
  对于想改造的方法 进行改造。
  对于想增加的方法 直接增加。
  这样可以将被装饰者传入，装饰，增加特定的功能。

  StringReader

  数据来源是字符串的字符输入流，可以将一个字符串作为数据来源 以流的方式获取其中的数据

  字节流

  InputStream - FileInputStream
  以字节为基本单位来操作数据
  构造方法：
  FileInputStream(File file)
  FileInputStream(String name)
  方法：
  int read()
  int read(byte[] b)
  int read(byte[] b, int off, int len)
  int available()
  void close()

   案例：以字节为单位从文件中读取数据
  

  OutputStream - FileOutputStream
  以字节为基本单位来操作数据
  构造方法：
  FileOutputStream(File file)
  FileOutputStream(String name)
  方法：
  void write(int b)
  void write(byte[] b)
  void write(byte[] b, int off, int len)
  void flush()
  void close()

   案例：以字节为单位向文件写出数据
  
   案例：利用字节流实现文件的拷贝 文本文件 和 非文本文件都可以拷贝
  
   案例：利用字节流实现文件的拷贝 - 自定义缓冲区提升性能
  

  转换流

目录,再往上一拉
字符流的底层也是通过字节来操作数据的 只不过在字节流的基础上增加了 默认的转换器 可以经字节和字符进行映射 采用的编码集为系统码 且无法更改
所以当使用字符流 操作 非系统码的文件时 可能产生乱码
此时可以通过转换流 将自己构建的字节流 转换为字符流 并在这个过程中 指定需要的编码集 来解决问题
InputStreamReader - 可以将字节输入流转换为字符输入流 在转换的过程中 其实内部就是多了一个将字节 映射为 字符的操作 而采用的编码集 可以由程序来指定
构造方法：
InputStreamReader(InputStream in) //将字节输入流转换为字符输入流 内部增加的转换器 采用默认的码表(系统码)
InputStreamReader(InputStream in, String charsetName) //将字节输入流转换为字符输入流 内部增加的转换器 采用的码表由charsetName来指定
方法：
int read()
int read(char[] cbuf)
int read(char[] cbuf, int offset, int length)
void close()
OutputStreamWriter - 可以将字节输出流转换wie字符输出流 在转换的过程中 其实内部就是多了一个将字符 映射为 字节的操作 而采用的编码集 可以由程序来指定
构造方法：
OutputStreamWriter(OutputStream out)//将字节输出流转换为字符输出流 内部增加的转换器 采用默认的码表(系统码)
OutputStreamWriter(OutputStream out, String charsetName) //将字节输出流转换为字符输出流 内部增加的转换器 采用的码表由charsetName来指定
方法：
void write(int c)
void write(char[] cbuf)
void write(char[] cbuf, int off, int len)
void write(String str)

	案例5：利用转换流实现utf-8编码集的文本文件的拷贝	
	案例6(作业)：请写程序将gbk的文本文件转换为utf-8的文本文件 实现一个转码的过程
	案例7(作业)：请写程序将utf-8的文本文件转换为gbk的文本文件 实现一个转码的过程

// 在流使用完成之后会自动的进行关流操作
		// try-with-resources 从JDK1.7开始的
		// 要求能够使用try-with-resources方式的流必须实现AutoCloseable
		// 要求流的创建过程必须在try之内
		try (FileWriter writer = new FileWriter("D:\\c.txt")) {
			writer.write("def");
			writer.write("abe");
			writer.flush();
		} catch (IOException e) {
			e.printStackTrace();
		}

目录,再往上一拉

package cn.tedu.io;

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo1 {

	public static void main(String[] args) throws IOException {

		// 表示创建了一个输出流指向D盘下的a.txt
		// 创建一个新的文件：如果原文件已存在则用新文件覆盖原文件
		// 如果原文件不存在，创建一个新的文件,则将新文件作为目标文件进行操作
		FileWriter writer = new FileWriter("D:\\b.txt");
		// 追加方式
		// 原文件已存在，不会创建新文件而是直接利用原文件
//		FileWriter writer = new FileWriter("D:\\a.txt", true);

		// 写出数据
		// 数据不是直接写到文件中
		// 而是先写到缓冲区中
		// 缓冲区被填满之后再将缓冲区中的数据放到文件中
		// 缓冲区还没有被填满，然后程序结束了
		// 就导致有一部分数据死在缓冲区中没有来得及放到文件中
		// 导致数据产生了丢失
		writer.write("xyz");

		// 冲刷缓冲区
		// writer.flush();

		// 关闭流
		// 流在关闭的时候会自动冲刷一次缓冲区
		writer.close();

		// 流关闭了，流对象在内存中还存在吗？--- 存在
		System.out.println(writer);
		// 表示将流对象的引用置为null，手动标记它是一个垃圾对象(值为null)可以被回收
		writer = null;
	}

}

目录,再往上一拉

package cn.tedu.io;

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo2 {

	public static void main(String[] args) {

		// 将writer放到try之外声明并赋值为null
		FileWriter writer = null;
		try {
			// 将writer放到try之内初始化
			writer = new FileWriter("H:\\b.txt");
			writer.write("abc");
			// 为了防止关流的时候自动冲刷失败导致数据的丢失
			writer.flush();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			// 需要判断writer是否初始化成功
			if (writer != null)
				try {
					writer.close();
				} catch (IOException e) {
					e.printStackTrace();
				} finally {
					// 如果关流失败，则强制将流对象置为null进行回收以释放文件
					// 如果关流成功，则将流对象标记为垃圾对象
					writer = null;
				}
		}

	}

}

4.系统流
System是java内置的代表当前系统的类 其上提供了很多和系统相关的属性和方法 方便我们对系统进行操作
常用的属性：
static InputStream in - 标准输入流
static PrintStream out - 标准输出流
static PrintStream err - 标准错误输出流
常用的方法：
static void exit(int status) //退出虚拟机
static void gc() //启动垃圾回收 虚拟机通常会根据自身的内存使用情况 自动决定什么时候来进行垃圾回收 但是也可以通过这个方法 通知虚拟机该垃圾回收 但是注意 这个方法调用并不会触发垃圾回收 只是一个通知告诉虚拟机该回收垃圾了 至于是否启动垃圾回收 仍然由虚拟机自己决定
static void setIn(InputStream in) //设定系统标准输入流
static void setOut(PrintStream out) //设定系统标准输出流
static void setErr(PrintStream err) //设定系统标准错误输出流

系统流

其中System上提供的 in out err三个字节流 称之为系统流
系统流其实也是字节流 只不过这个字节流不需要我们自己创建 是系统创建好 直接提供给我们用的 不要关 也不能关
其中 in 是系统输入流 从系统标准输入流中获取数据 默认的系统标准输入流的来源 是控制台
其中 out err 是系统输出流 向系统标准输出流中写出数据 默认的系统标准输出流的目的地 是控制台

所以，平常大家写的 System.out.println(“hello world~”); 起始就是通过System.out得到的了系统输出流 向这个流中 通过println方法写出了 数据 最终去往了控制台显示
也可以用 System.err.println(“xxx”) 写出数据 和 System.out 唯一的不同是 打印出来将会是红色的文本 更加醒目 通常用来打印错误信息 平常大家见到的异常信息 就是通过System.err打印的
系统输出流的默认位置是控制台 也可以通过System.setOut() 或System.setErr() 方法修改out或err指向的 系统输出流

而 其中的System.in代表标准输入流 默认数据来源是控制台 所以可以利用它从控制台中读取数据
所以平常从控制态中读取数据可以写成：
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))
简单写法
Scanner scanner = new Scanner(System.in)
系统标准输入流默认的位置是控制台 也可以通过System.setIn() 方法来修改系统默认输入流 从而从其他位置读取数据

打印流

采用了装饰设计模式 为普通输出流 增加打印功能

PrintStream
可以讲普通的字节流转换为打印字节流 这也是一个装饰设计模式 增加了打印的机制 有如下的三个好处
打印流增加了打印各种类型数据的方法，省去了将各种类型的数据转换为字节再输出的过程。
打印流会自动刷新流，不需要手动进行flush。
打印流永远不抛异常，它的内部自动解决异常。

PrintWriter
可以将普通的字符流转换为打印字符流 这也是一个装饰设计模式 增加了打印的机制 有如下的三个好处
打印流增加了打印各种类型数据的方法，省去了将各种类型的数据转换为字符再输出的过程。
打印流会自动刷新流，不需要手动进行flush。
打印流永远不抛异常，它的内部自动解决异常。

练习

1
目录,再往上一拉

/**
 * 案例：编写一个流 来读取外部文件中的字符数据 	
 */
public class Demo01 {
	public static void main(String[] args) throws Exception {
		//1.创建文件字符输入流链接到 1.txt上
		Reader reader = new FileReader("1.txt");
		//2.通过流读取文件中的数据
		int i = 0;
		while((i=reader.read())!=-1){
			System.out.println((char)i);
		}
		//3.关闭流
		reader.close();
	}
}

2
目录,再往上一拉

/**
 * 案例：编写一个流 来将指定的字符写出到外部文件中
 */
public class Demo02 {
	public static void main(String[] args) throws Exception {
		//1.创建文件字符输出流
		Writer writer = new FileWriter("2.txt");
		//2.通过字符输出流输出数据
		writer.write((int)'a');
		writer.write((int)'b');
		writer.write((int)'c');
		writer.write((int)'d');
		writer.write((int)'e');
		//3.刷新流
		//writer.flush();
		//--关闭流，关闭流过程中会隐含的刷新一次流
		writer.close();
	}
}

3
目录,再往上一拉

/**
 * 案例：利用字符流实现字符文件的拷贝 1.txt -> 3.txt
 */
public class Demo03 {
	public static void main(String[] args) {
		Reader reader = null;
		Writer writer = null;
		try {
			//1.创建字符输入流 连接1.txt 创建字符输出流 连接3.txt
			reader= new FileReader("1.txt");
			writer = new FileWriter("3.txt");
			//2.从1.txt读取数据
			int i = 0;
			while((i = reader.read())!=-1){
				writer.write(i);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//3.关闭流
			if(reader!=null){
				try {
					reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				} finally{
					reader = null;
				}
			}
			if(writer!=null){
				try {
					writer.close();
				} catch (IOException e) {
					e.printStackTrace();
				} finally{
					writer = null;
				}
			}
		}
		
	}
}

4
目录,再往上一拉

/**
 * 通过字符流 拷贝字符文件 讨论效率问题
 */
public class Demo04 {
	public static void main(String[] args){
		//--开始时间
		long begin = System.currentTimeMillis();
		
		Reader reader = null;
		Writer writer = null;
		try {
			//1.创建流
			reader = new FileReader("4.txt");
			writer = new FileWriter("5.txt");
			//2.拷贝数据
			//int count = 0;
			int i = 0;
			char [] buf = new char [1024];
			while ((i = reader.read(buf)) != -1) {
				//System.out.println("读取了"+(++count)+"次");
				writer.write(buf,0,i);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//3.关闭流
			if(reader!=null){
				try {
					reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				} finally{
					reader = null;
				}
			}
			if(writer!=null){
				try {
					writer.close();
				} catch (IOException e) {
					e.printStackTrace();
				} finally {
					writer = null;
				}
			}
		}
		//--结束时间
		long end = System.currentTimeMillis();
		System.out.println("====共耗时："+(end-begin)+"ms====");
	
	}
}

5
目录,再往上一拉

/**
 * 使用 缓冲流 BufferedReader BufferedWriter复制文本文件
 */
public class Demo05 {
	public static void main(String[] args) throws Exception {
		//1.创建 带有缓冲区的 文件输入流 文件输出流 
		FileReader reader = new FileReader("4.txt");
		BufferedReader breader = new BufferedReader(reader);
		FileWriter writer = new FileWriter("5.txt");
		BufferedWriter bwriter = new BufferedWriter(writer);
		
		//2.连接流 复制文件
		int i = 0;
		char [] buf = new char[1024];
		while((i = breader.read(buf))!=-1){
			bwriter.write(buf,0,i);
		}
		
		//3.关闭流
		breader.close();
		bwriter.close();
		
	}
}

6
目录,再往上一拉

/**
 * BufferedReader和BufferedWriter提供的新方法
 * 
 * BufferedReader
 * 	readline()
 * 
 * BufferedWriter
 * 	newLine() 
 */
public class Demo06 {
	public static void main(String[] args) throws Exception {
		//1.创建流 并用缓冲流包装
		BufferedReader reader = new BufferedReader(new FileReader("1.txt"));
		BufferedWriter writer = new BufferedWriter(new FileWriter("2.txt"));
		
		//2.对接流 拷贝文件
		String line = null;
		while((line = reader.readLine())!=null){
			writer.write(line);
			writer.newLine();
		}
		
		//3.关闭流
		reader.close();
		writer.close();
	
	}
}

7 - 装饰设计模式
目录,再往上一拉

package cn.tedu.io1;


public class Demo07 {
	public static void main(String[] args) {
		//--继承
//		Man man = new Man("zs",19);
//		man.eat();
//		man.sleep();
//		
//		SuperMan1 sp = new SuperMan1("zs", 19);
//		sp.eat();
//		sp.sleep();
//		sp.fly();
		
		//--装饰
		Man man = new Man("ls",20);
		man.eat();
		man.sleep();
		
		SuperMan2 sman = new SuperMan2(man);
		sman.eat();
		sman.sleep();
		sman.fly();
	}
}

/**
 * 装饰设计模式
 */
class SuperMan2 implements Ani{
	private Man man = null; 
	public SuperMan2(Man man) {
		this.man = man;
	}
	@Override
	public void eat() {
		System.out.println("绕地球飞一圈。。");
		man.eat();
		System.out.println("到太平洋里游一圈。。");
	}
	@Override
	public void sleep() {
		man.sleep();
	}
	
	public void fly(){
		System.out.println(man.name + "飞。。。");
	}
}


interface Ani{
	public void eat();
	public void sleep();
}

class Man implements Ani{
	protected String name;
	protected int age;
	
	public Man() {
	}
	
	public Man(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	public void eat(){
		System.out.println(name+"吃。。。");
	}
	public void sleep(){
		System.out.println(name+"睡。。。");
	}
	
}

/**
 * 继承方式
 */
class SuperMan1 extends Man{
	public SuperMan1() {
	}
	public SuperMan1(String name,int age){
		super(name,age);
	}
	
	public void fly(){
		System.out.println(super.name+"飞。。。");
	}
}

8
目录,再往上一拉

/**
 * StringReader的用法
 */
public class Demo08 {
	public static void main(String[] args) throws Exception {
		//1.创建StringReader
		String str = "hello java~ hello world~ 这是一段中文~";
		StringReader reader = new StringReader(str);
		//2.创建FileWriter
		FileWriter writer = new FileWriter("7.txt");
		//2.对接流输出
		int i = 0;
		char [] cs = new char[1024];
		while((i = reader.read(cs))!=-1){
			writer.write(cs,0,i);
		}
		//3.关闭流
		reader.close();
		writer.close();
	}
}

9
目录,再往上一拉

/**
 * 利用字节流实现文件的复制
 */
public class Demo01 {
	public static void main(String[] args) throws Exception {
		//1.创建流
		InputStream in = new FileInputStream("1.wmv");
		OutputStream out = new FileOutputStream("2.wmv");
		//2.对接流 实现复制
		int i = 0;
		while((i = in.read())!=-1){
			out.write(i);
		}
		//3.关闭流
		in.close();
		out.close();
	}
}

10
目录,再往上一拉

/**
 * 利用字节流实现文件的复制 - 使用缓冲区
 */
public class Demo02 {
	public static void main(String[] args) throws Exception {
		//1.创建流
		InputStream in = new FileInputStream("1.wmv");
		OutputStream out = new FileOutputStream("2.wmv");
		//2.对接流 实现复制
		int i = 0;
		byte [] tmp = new byte[1024];
		while((i = in.read(tmp))!=-1){
			out.write(tmp,0,i);
		}
		//3.关闭流
		in.close();
		out.close();
	}
}

11
目录,再往上一拉

/**
 * 案例：通过转换流 生成自定义码表的字符流 复制文件 解决乱码
 */
public class Demo04 {
	public static void main(String[] args) throws Exception {
		//1.创建字节流
		InputStream in = new FileInputStream("d://8.txt");
		OutputStream out = new FileOutputStream("d://9.txt");
	
		//2.创建转换流 将字节流转换为字符流 并显式指定码表为utf-8
		InputStreamReader reader = new InputStreamReader(in,"utf-8");
		OutputStreamWriter writer = new OutputStreamWriter(out,"utf-8");
		
		//3.对接流 复制文件
		char [] data = new char[1024];
		int i = 0;
		while((i=reader.read(data))!=-1){
			writer.write(data,0,i);
		}
		
		//4.关闭流
		reader.close();
		writer.close();
	}
}

12
目录,再往上一拉

/**
 * 案例：通过转换流 生成自定义码表的字符流 复制文件 将utf-8文件转换为gbk格式的文件
 */
public class Demo05 {
	public static void main(String[] args) throws Exception {
		//1.创建字节流
		InputStream in = new FileInputStream("d://8.txt");
		OutputStream out = new FileOutputStream("d://9.txt");
	
		//2.创建转换流 将字节流转换为字符流 并显式指定码表为utf-8
		InputStreamReader reader = new InputStreamReader(in,"utf-8");
		OutputStreamWriter writer = new OutputStreamWriter(out,"gbk");
		
		//3.对接流 复制文件
		char [] data = new char[1024];
		int i = 0;
		while((i=reader.read(data))!=-1){
			writer.write(data,0,i);
		}
		
		//4.关闭流
		reader.close();
		writer.close();
	}
}

13
目录,再往上一拉

public class Demo06 {
	public static void main(String[] args) throws Exception {
//		System.setOut(new PrintStream(new FileOutputStream("out.txt")));
//		System.setErr(new PrintStream(new FileOutputStream("err.txt")));
//		System.out.println("abc");
//		System.err.println("xyz");
	
//		InputStream in = System.in;
//		System.out.println((char)in.read());
//		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
//		String line = reader.readLine();
//		System.out.println(line);
	
//		Scanner scanner = new Scanner(System.in);
//		String line = scanner.nextLine();
//		System.out.println(line);
		
		
//		System.setIn(new FileInputStream("in.txt"));
//		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
//		String line = null;
//		while((line = reader.readLine())!=null){
//		System.out.println(line);
//		}
	}
}