JavaSE：异常、IO

1、异常

1.1 异常的体系

Throwable
	|--Error	严重问题，我们不处理。
	|--Exception
		|--RuntimeException	运行期异常，我们需要修正代码
		|--非RuntimeException 编译期异常，必须处理的，否则程序编译不通过

1.2 异常的处理

自己编写处理代码,后面的程序可以继续执行
try...catch...finally
try...catch...
try...catch...catch...
try...catch...catch...fianlly
try...finally

第一种:try...catch...finally的处理格式：
		try {
			可能出现问题的代码;
		}catch(异常名 变量) {
			针对问题的处理;
		}finally {
			释放资源; //finally控制的语句体一定会执行
		}

把自己处理不了的，在方法上声明，告诉调用者，这里有问题
throws
第二种格式：
 		throws 异常类名
 		注意：这个格式必须跟在方法的括号后面。

1.3 异常注意事项

A:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)
B:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
C:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws

1.4 final,finally和finalize的区别

 final：最终的意思，可以修饰类，成员变量，成员方法
 		修饰类，类不能被继承
 		修饰变量，变量是常量
 		修饰方法，方法不能被重写
 finally：是异常处理的一部分，用于释放资源。
 		一般来说，代码肯定会执行，特殊情况：在执行到finally之前jvm退出了
 finalize：是Object类的一个方法，用于垃圾回收

2、File

File:文件和目录(文件夹)路径名的抽象表示形式
构造方法：
 		File(String pathname)：根据一个路径得到File对象
 		File(String parent, String child):根据一个目录和一个子文件/目录得到File对象
 		File(File parent, String child):根据一个父File对象和一个子文件/目录得到File对象
 
创建功能：
	public boolean createNewFile():创建文件 如果存在这样的文件，就不创建了
  	public boolean mkdir():创建文件夹 如果存在这样的文件夹，就不创建了
  	public boolean mkdirs():创建文件夹,如果父文件夹不存在，会帮你创建出来
  	
 删除功能:public boolean delete()	  	
  	要删除一个文件夹，请注意该文件夹内不能包含文件或者文件夹
  	
 重命名功能:public boolean renameTo(File dest)
 		如果路径名相同，就是改名。
 		如果路径名不同，就是改名并剪切。  	
 
 判断功能:
 public boolean isDirectory():判断是否是目录
 public boolean isFile():判断是否是文件
 public boolean exists():判断是否存在
 public boolean canRead():判断是否可读
 public boolean canWrite():判断是否可写
 public boolean isHidden():判断是否隐藏
 
 获取功能：
 public String getAbsolutePath()：获取绝对路径
 public String getPath():获取相对路径
 public String getName():获取名称
 public long length():获取长度。字节数
 public long lastModified():获取最后一次的修改时间，毫秒值
 
 获取功能：
 public String[] list():获取指定目录下的所有文件或者文件夹的名称数组
 public File[] listFiles():获取指定目录下的所有文件或者文件夹的File数组

public class FileDemo {
	public static void main(String[] args) throws IOException {
		// File(String pathname)：根据一个路径得到File对象
		// 把e:\\demo\\a.txt封装成一个File对象
		File file = new File("E:\\demo\\a.txt");
		System.out.println(file);
		// File(String parent, String child):根据一个目录和一个子文件或子目录得到File对象
		File file2 = new File("E:\\demo", "a.txt");
		System.out.println(file2);
		// File(File parent, String child):根据一个父File对象和一个子文件或目录得到File对象
		File file3 = new File("e:\\demo");
		File file4 = new File(file3, "a.txt");
		System.out.println(file4);
		// 以上三种方式其实效果一样
		
//		 *创建功能：
//			public boolean createNewFile():创建文件 如果存在这样的文件，就不创建了
//		  	public boolean mkdir():创建文件夹 如果存在这样的文件夹，就不创建了
//		  	public boolean mkdirs():创建文件夹,如果父文件夹不存在，会帮你创建出来
		//File file5=new File("E:\\demo");
		//System.out.println("mkdir:" + file5.mkdir());
		//File file6 = new File("e:\\demo\\a.txt");
		//System.out.println("createNewFile:" + file6.createNewFile());
			
		
	}
}

3、IO流

3.1 IO流分类

流向：
			输入流in		读取数据
			输出流out	写入数据
数据类型：
			字节流	
					字节输入流
					字节输出流
			字符流
					字符输入流
					字符输出流

IO流
|--字节流
	|--字节输入流
		InputStream
			int read():一次读取一个字节
			int read(byte[] bys):一次读取一个字节数组
		
			|--FileInputStream
			|--BufferedInputStream
	|--字节输出流
		OutputStream
			void write(int by):一次写一个字节
			void write(byte[] bys,int index,int len):一次写一个字节数组的一部分
			
			|--FileOutputStream
			|--BufferedOutputStream
|--字符流
	|--字符输入流
		Reader
			int read():一次读取一个字符
			int read(char[] chs):一次读取一个字符数组
			
			|--InputStreamReader
				|--FileReader
			|--BufferedReader
				String readLine():一次读取一个字符串
	|--字符输出流
		Writer
			void write(int ch):一次写一个字符
			void write(char[] chs,int index,int len):一次写一个字符数组的一部分
			
			|--OutputStreamWriter
				|--FileWriter
			|--BufferedWriter
				void newLine():写一个换行符
				
				void write(String line):一次写一个字符串

3.2 字节流读写FileInputStream、FileOutputStream

3.3 字节流读写BufferedInputStream、BufferedOutputStream

write写：
public void write(int b):写一个字节
public void write(byte[] b):写一个字节数组
public void write(byte[] b,int off,int len):写一个字节数组的一部分

读取数据的方式：
A:int read():一次读取一个字节
B:int read(byte[] b):一次读取一个字节数组

public class FileOutputStreamDemo {
	public static void main(String[] args) throws IOException {
		FileOutputStream fos=new FileOutputStream("fos.txt");
		fos.write("hello,io".getBytes());
		fos.write("\njava".getBytes());
		
		//释放资源
		fos.close();
		
		FileOutputStream fos2=new FileOutputStream("fos2.txt");
		byte[] bys={97,98,99,100,101};
		fos2.write(bys);
		fos2.close();
		
		FileInputStream fis=new FileInputStream("fos.txt");
		int by=0;
		while((by=fis.read())!=-1){
			System.out.print((char)by);
		}
		fis.close();
		
		// 封装数据源
		FileInputStream fis1 = new FileInputStream("fos.txt");
		// 封装目的地
		FileOutputStream fos1 = new FileOutputStream("b.txt");
		int by1 = 0;
		while ((by1 = fis1.read()) != -1) {
			fos1.write(by1);
		}
		// 释放资源(先关谁都行)
		fos1.close();
		fis1.close();
		
//		 * BufferedOutputStream(OutputStream out)
//		 * BufferedInputStream(InputStream in)
		BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("bos.txt"));
		bos.write("hello".getBytes());
		bos.close();
		
		BufferedInputStream bis=new BufferedInputStream(new FileInputStream("bos.txt"));
		int bis1=0;
		while((bis1=bis.read())!=-1){
			System.out.print((char)bis1);
		}
	}
}

3.4 字符流读写InputStreamReader、OutputStreamWriter

InputStreamReader(InputStream is):用默认的编码读取数据
InputStreamReader(InputStream is,String charsetName):用指定的编码读取数据

InputStreamReader的方法：
int read():一次读取一个字符
int read(char[] chs):一次读取一个字符数组

public class OutputStreamWriterDemo {
	public static void main(String[] args) throws IOException {
		OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("osw.txt"));
		osw.write("中国");
		osw.close();
		
	}
}

InputStreamReader(InputStream is):用默认的编码读取数据
InputStreamReader(InputStream is,String charsetName):用指定的编码读取数据

InputStreamReader的方法：
int read():一次读取一个字符
int read(char[] chs):一次读取一个字符数组

public class InputStreamReaderDemo {
	public static void main(String[] args) throws IOException {
		InputStreamReader isr=new InputStreamReader(new FileInputStream("osw.txt"));
		int ch=0;
		while ((ch=isr.read())!=-1){
			System.out.print((char)ch);
		}
		isr.close();
	}

}

3.5 字符流缓冲BufferedWriter、BufferedReader

BufferedWriter:
		public void newLine():根据系统来决定换行符
BufferedReader:
		public String readLine()：一次读取一行数据
		包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

public class BufferedDemo {
	public static void main(String[] args) throws IOException {
		BufferedWriter bw=new BufferedWriter(new FileWriter("bw.txt"));
		for(int x=0;x<5;x++){
			bw.write("hello"+x);
			bw.newLine();
			bw.flush();
		}
		bw.close();
		
		BufferedReader br=new BufferedReader(new FileReader("bw.txt"));
		String line=null;
		while((line=br.readLine())!=null){
			System.out.println(line);
		}
		br.close();
		
	}
}