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（处理流，用来给节点流添加功能，装饰者）