JAVA笔记八（30—34 异常和IO）

三十、JAVA当中的异常（一）

1.什么是异常

异常：中断了正常指令流的事件；（异常是在程序运行时产生的，跟编译时出的语法错误不是一个东西）

class Test{
	public static void main(String [] args){
		System.out.println(1);
		int i = 1 / 0;      //uncheck exception.
		System.out.println(2);
	}
}

运行结果：

2.异常的分类

JDK的异常类：

Error是虚拟机运行时产生的错误，一旦程序产生Error，虚拟机直接退出。只能尽可能减少Error的出现。

Exception包含两大类：1）运行时异常(uncheck exception)。 2）编译时异常(check exception)。

class TestCheck{
	public static void main(String[] args){
		Thread.sleep(1000);  //check exception.
	}
}

运行结果：

3.try…catch…finally结构的使用方法

class Test{
	public static void main(String [] args){
		System.out.println(1);
		//uncheck exception
		try{
			int i = 1 / 0;	//try的大括号里面放有可能出现异常的代码。
		}
		catch(Exception e){	//若try大括号里面出现异常，则跳到catch里面执行。若无异常，catch里的代码不执行。
			e.printStackTrace();	//e为虚拟机产生的异常对象。
		}
		finally{	//finally里面的代码，不管出不出异常，都执行。所有叫做异常的出口。
		}			//经常用来做一些清理工作，比如关闭文件、关闭数据库、关系socket等...
		System.out.println(2);
	}

总结：

1）广义上来说，异常分为Error和Exception，程序员对Error无能为力，只能处理Exception。Exception分为两类。一类是check Exception，是Exception的直接子类；一类是uncheck Exception，是RuntimeException以及它的子类。

  2）对异常的处理关系到系统的健壮性。不能因为一点小错误，程序就崩溃。出现一点点错误，我们还可以处理，使程序还能继续运行。

  3）try…catch…finally结构可以用来处理可能出现的异常。把可能出现的异常放在try里，把对异常处理的代码放在catch里，把清理资源的代码放在finally里。

三十一、java当中的异常（二）

1.throw的作用

class User{
	private int age;
	
	public void setAge(int age){
		if(age <0){
			RuntimeException r = new RuntimeException("年龄不能为负数"); 
			throw r; //抛出之后，程序运行到这里就终止了。
		}
		this.age = age;
	}
}

class Test{
	public static void main(String [] args){
		User u = new User();
		u.setAge(-20);
	}
}

运行Test的结果：

2.throws的作用

class User{
	private int age;
	
	public void setAge(int age) throws Exception{	//声明异常。则此处不出来异常；谁调用setAge,谁处理异常。
		if(age <0){
			Exception r = new Exception("年龄不能为负数");
			throw r; 
		}
		this.age = age;
	}

class Test{
	public static void main(String [] args){
		User u = new User();
		try{
			u.setAge(-20);
		}
		catch(Exception r){
			System.out.println(r);
		}
	}
}

在函数中有可能产生check Exception的时候，可以选择在可能产生异常的代码上加上try…catch；也可以在函数后面声明这个函数可能产生Exception。一旦声明了，则此函数没有责任处理这个异常，而是由调用这个函数的地方来处理这个异常。

总结：

1）throw的作用：如果这个异常java虚拟机判断不了，可以在出现这种情况的时候，生成一个异常对象，用throw加上这个异常对象，抛出这个异常，java虚拟机就可以知道这里出现异常了。

2）throws的作用：你可以用throws这个关键字来声明一个函数有可能出现异常，这个函数不对这个异常进行处理。而是在调用这个函数的地方来处理异常。

三十二、java当中的IO（一）（最重要的部分）

1.I/O操作的目标

从数据源当中读取数据，以及将数据写入到数据目的地当中。

I/O的流向：

有数据进入java程序中，就是input；数据从程序中到文件中，就是output；

2.IO的分类方法

第一种分法：1）输入流； 2）输出流；

第二种分法：1）字节流； 2）字符流；

第三种分法：1）节点流； 2）处理流；（处理流是在节点流的基础上加上对数据的处理）

3.读取文件和写入的方法

I/O当中的核心类（字节流的核心类）：InputStream和OutputStream都是抽象类。

核心类的核心方法

InputStream:

intread(byte [] b,int off,int len)

OutputStream:

voidwrite(byte [] b,int off, int len)

读取数据和写入数据实例：

//第一步骤：导入类；
import java.io.*;

class test{
	public static void main(String args[]){
		//声明输入流引用
		FileInputStream fis = null;
		
		//声明输出流引用
		FileOutputStream fos = null;
		
		try{    //在操作IO时，会产生编译器异常。要求我们对它进行处理。
			
			//生成代表输入流的对象
			fis = new FileInputStream("e:/java/src/from.txt");
			
			//生成代表输出流的对象
			fos = new FileOutputStream("e:/java/src/to.txt");
			
			//生成一个字节数组
			byte [] buffer = new byte[100]; //byte类型数组默认初始化的每一个元素都是0.
			
			//调用输入流对象的read方法，读取数据
			int temp = fis.read(buffer,0,buffer.length);	//把字符转换成ASCII码，以字节的方式读取。
			//read函数的返回值是这次一共读取了多少个字节的数据;用temp接受返回值。
			
			/**把数组还原成字符串
			*String s = new String(buffer);
			**调用一个String对象的trim方法，将会去除这个字符串的首位空格和空字符。
			*s = s.trim();
			*System.out.println(s);
			**/
			
			//调用输出流对象的write方法，写入数据
			fos.write(buffer,0,temp);
		}
		catch(Exception e){
			System.out.println(e);
		}
	}
}

三十三、java中的I/O（二）

1、大文件的读写方法

读写大文件，采取循环读写方法。

import java.io.*;

class test{
	public static void main (String[] args){
		FileInputStream fis = null;
		FileOutputStream fos = null;
		
		try{
			fis = new FileInputStream("e:/java/src/from.txt");
			fos = new FileOutputStream("e:/java/src/to.txt");
			
			byte [] buffer = new byte [1024];
			
			//大文件，使用循环的方式读取写入。
			while(true){
			int temp = fis.read(buffer,0,buffer.length);  //文件读完了，read返回值为-1.
				if (temp == -1){
					break;
				}
			fos.write(buffer,0,temp);
			}
		
		}
		
		catch(Exception e){
			System.out.println(e);
		}
		
		finally{
			try{
				fis.close();  //关闭输入流；
				fos.close();  //关闭输出流；
			}
			catch(Exception e){
				System.out.println(e);
			}
		}
	
	}
}

2、字符流的使用方法（文本用字符流比较方便）

//字符流：读写文件时，以字符为基础
//字节输入流：Reader <——FileReader
//int read(char [] c,int off, int len)
//字节输出流：Writer <——FileWriter
//void write(char [] c,int off, int len)

import java.io.*;

public class testChar{
	public static void main(String [] args){
		FileReader fr = null;
		FileWriter fw = null;
		try{
			fr = new FileReader("e:/java/src/from.txt");
			fw = new FileWriter("e:/java/src/to.txt");
			char [] buffer = new char [1024];
			while(true){
			int temp = fr.read(buffer,0,buffer.length);
			if(temp == -1){
				break;
			}			
			fw.write(buffer,0,temp);
			}
		}
		catch(Exception e){
			System.out.println(e);
		}
		finally{
			try{
				fr.close();
				fw.close();
			}
			catch(Exception e){
				System.out.println(e);
			}		
		}	
	}
}

三十四、java中的IO（三）

1.处理流使用实例

BufferedReader（字符输入处理流）介绍：public   String  readLine()

BufferedReader使用方法：生成BufferedReader对象的方法：

BufferedReader    in  =  new    BufferedReader(newFileReader("foo.in"));

import java.io.*;

class test{
	public static void main(String[] args){
		FileReader filereader = null;
		BufferedReader bufferedReader = null;
		try{
			filereader = new FileReader("e:/java/src/from.txt");
			bufferedReader = new BufferedReader(filereader);
			//打印一行
			//String line = bufferedReader.readLine();
			//System.out.println(line);
			
			//打印所有行：
			String line = null;
			while(true){
				line = bufferedReader.readLine();
				if(line == null){
					break;
				}
				System.out.println(line);
			}
		}
		catch(Exception e){
			System.out.println(e);
		}
		finally{
			try{
				filereader.close();
				bufferedReader.close();
			}
			catch(Exception e){
				System.out.println(e);
			}		
		}
	}
}

2.“装饰者（Decorator）”模式

（java中IO系统使用最多的设计模式）

3.节点流与处理流的关系

FileReader（节点流，真正用来读取数据的，被装饰者）

BufferedReader（处理流，用来给节点流添加功能，装饰者）