一、异常的概念
异常指的是运行期出现错误，也就是当程序开始执行以后执行期出现的错误。
Java程序的执行过程如果出现异常事件，可以生成一个异常类对象，该异常对象封装了异常事件的信息并将被提交给Java运行时系统，这个过程称为抛出异常。
当Java运行时系统接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交给其处理，这一过程称为捕获异常。
public class TestEx{
public static void main(String args[]){
int arr[]={1,2,3};
System.out.println(arr[2]);
/**
* 这里使用try……catch来捕获除以0产生的异常，其基本格式是：
* try{
statements;//可能产生异常的语句
……
}
catch(Throwable-subclass e){//异常参数e
statements;//异常处理程序
……
}
*/
try{
System.out.println(arr[2]/0);
}catch(ArithmeticException ae){//这里是这个异常参数的类型声明，即声明这个异常是属于哪种类型的异常
System.out.println("系统正在维护中，请稍后！");
/**
* 这里使用printStackTrace()方法把这个错误的堆栈信息打印出来。
* 所谓的“错误堆栈信息”指的是这个错误有可能是上一个错误引起的，
* 而上一个错误又有可能是由另外一个错误引起的。到底是由哪个错误引起的，
* 把所有的错误信息全都打印出来就知道了。这种信息往往能给我们程序员调试错误的提示。
* 这些信息很有用，因此我们往往使用这个方法把错误信息打印出来。
* 默认打印错误提示信息采用的也是使用这种方法打印出来的
*/
ae.printStackTrace();
}
}
}
输出结果：
3
系统正在维护中，请稍后！
java.lang.ArithmeticException: / by zero
at test.TestEx.main(TestEx.java:19)
三、异常的捕获处理
Java异常处理的五个关键字：try、catch、finally、throw、throws。
1.try...catch...finally
public class TestEx{
public static void main(String[] args) {
try{
/*
* try语句块，表示要尝试运行代码，try语句块中代码受异常监控，其中代码发生异常时，会抛出异常对象。
* 如果try中出现异常，异常抛出后，将执行catch中的代码，如果没有抛出异常catch中的代码不执行
*/
}catch(ChildrenException e){
/*
* 当捕获ChildrenException异常时，执行该catch中代码
*/
e.printStackTrace();
}catch (FatherException e) {
/*
*当捕获FatherException异常时，执行该catch中的代码
*/
e.printStackTrace();
}finally{
/*
* 无论是否抛出异常，都执行finally中的代码，一般用来关闭各种资源
*/
}
}
}
2.throw、throws
public class TestEx{
/*
* throws声明方法中可能抛出的异常
*/
public void function1() throws Exception{
if(true){
/*
* throw抛出异常对象
*/
throw new RuntimeException();
}
}
public void function2() throws Exception{
function1();
}
public void function3() throws Exception{
function2();
}
/*
* 异常沿着方法调用的顺序抛出，直到main方法中被捕获。
* 不能直接在main方法里把Exception抛出去交给JAVA运行时系统出力就完事了，这是一种不负责任的表现。
* 如果想把程序写得特别健壮，使用try……catch去捕获异常并处理掉捕获后的异常是必不可少的做法。
*/
public static void main(String[] args) {
TestEx t = new TestEx();
try {
t.function3();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Java通过throws声明方法可能抛出的异常，通过throw在方法体中抛出异常对象
小结：
- 每个catch代码声明其能处理一种特定类型的异常，当异常发生时程序会终止当前流程，根据异常类型去执行相应catch代码
- 当有多个catch代码时，子类异常类型不能再父类异常类型后面，如上面ChildrenException和FahterException不能互换位置
- finally代码块，不管是否抛出异常都将执行里面的代码
- 异常沿着方法调用的顺序往外抛，直到异常得到处理，如果没有处理最终将交给Java虚拟机，直接终止程序。
测试异常：
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class TestException {
/**
* 任何方法往外抛能处理的异常的时候都有一种简单的写法：“throws Exception”，
* 因为Exception类是所有能处理的异常类的根基类，因此抛出Exception类就会抛出所有能够被处理的异常类里了。
* 使用“throws Exception”抛出所有能被处理的异常之后，这些被抛出来的异常就是交给JAVA运行时系统处理了，
* 而处理的方法是把这些异常的相关错误堆栈信息全部打印出来。
* @throws Exception
*/
void fn() throws Exception {
}
/**
* 在知道异常的类型以后，方法声明时使用throws把异常往外抛
* @param i
* @throws ArithmeticException
*/
void m1(int i) throws ArithmeticException {
}
void m2(int i) {
if (i == 0) {
//这种做法就是手动抛出异常，使用“throw+new出来的异常对象”就可以把这个异常对象抛出去了。
//这里是new了一个异常对象，在构建这个对象的时候还可以指定他相关的信息，如这里指明了异常信息“i不能等于0”
//这个对象抛出去的时候使用getMessage()方法拿到的就是“i不能等于0”这种信息。
throw new ArithmeticException("i不能等于0");
}
}
/**
* 正常情况下如果这里不写try……catch语句那么程序编译时一定会报错，
* 因为这里有可能会产生两个个必须要处理的异常：FileNotFoundException和IOException。
* 但由于在声明方法f()时已经使用throws把可能产生的这两个异常抛出了，
* 所以这里可以不写try……catch语句去处理可能会产生的异常。
* f()方法把抛出的异常交给下一个要调用它的方法去处理
* @throws FileNotFoundException
* @throws IOException
*/
void f() throws FileNotFoundException, IOException {
//这里有可能会产生FileNotFoundException异常
FileInputStream fis = new FileInputStream("MyFile.txt");
//这里有可能会产生IOException异常
int b = fis.read();
while (b != -1) {
System.out.println((char)b);
b = fis.read();
}
}
/**
* 在f2()方法里面调用f()方法时必须要处理f()方法抛出来的异常，
* 当然，如果f2()方法也没有办法处理f()方法抛出来的异常，那么f2()方法也可以使用throws把异常抛出，
* 交给下一个调用了f2()的方法去处理f()方法抛出来的异常。
* 这里f2()调用f()方法时，选择不处理f()方法中可能抛出的异常，将异常继续抛出
* @throws Exception
*/
void f2() throws Exception {
f();
}
/**
* f3方法调用f方法捕获f()方法抛出的2个异常并进行处理
*/
void f3() {
try {
f();
} catch (FileNotFoundException e) {
System.out.println(e.getMessage());//处理的方法是把错误信息打印出来
} catch (IOException e) {
e.printStackTrace();//处理的方法是使用printStackTrace()方法把错误的堆栈信息全部打印出来。
}
}
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("MyFile.txt");
int b = fis.read();//这个有可能会抛出IOException异常
while (b != -1) {
System.out.println((char)b);
b = fis.read();
}
} catch (FileNotFoundException e) {
//使用catch捕获FileNotFoundException类异常的异常对象e。并让异常对象e自己调用printStackTrace方法打印出全部的错误信息
e.printStackTrace();
} catch (IOException e) {
//再次使用catch捕获IOException类的异常对象e，并让异常对象e自己调用getMessage()方法将错误信息打印出来。
System.out.println(e.getMessage());;
}finally{
try {
/**
* 前面已经把一个文件打开了，不管打开这个文件时有没有错误发生，即有没有产生异常，最后都一定要把这个文件关闭掉，
* 因此使用了finally语句，在finally语句里面不管前面这个文件打开时是否产生异常，在finally这里执行in.close()都能把这个文件关闭掉，
* 关闭文件也有可能会产生异常，因此在finally里面也使用了try……catch语句去捕获有可能产生的异常。
*/
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
四、自定义异常
如果现有异常类型不能满足需求，我们可以通过继承Exception及其子类来自定义异常，来满足需求。
/**
* 自定义的一个异常类MyException，且是从Exception类继承而来
*/
public class MyException extends Exception {
private int id;
/**
* 自定义异常类的构造方法
* @param message
* @param id
*/
public MyException(String message,int id) {
super(message);//调用父类Exception的构造方法
this.id = id;
}
/**
* 获取异常的代码
* @return
*/
public int getId() {
return id;
}
}
测试：
public class TestMyException {
//throws MyException,抛出我们自定义的MyException类的异常。
public void regist(int num) throws MyException {
if (num < 0) {
//使用throw手动抛出一个MyException类的异常对象。
throw new MyException("人数为负值，不合理", 1);
}
/**
* 注意：当我们抛出了异常之后，
* System.out.println(MessageFormat.format("登记人数：{0}",num));是不会被执行的。
* 抛出异常之后整个方法的调用就结束了。
*/
System.out.println(MessageFormat.format("登记人数：{0}",num));
}
public void manage() {
try {
regist(-100);
} catch (MyException e) {
System.out.println("登记失败，错误码："+e.getId());
e.printStackTrace();
}
System.out.println("操作结束");
}
public static void main(String[] args) {
TestMyException t = new TestMyException();
t.manage();
}
}
输出结果：
登记失败，错误码：1
test.MyException: 人数为负值，不合理
操作结束
at test.TestMyException.regist(TestMyException.java:11)
at test.TestMyException.manage(TestMyException.java:23)
at test.TestMyException.main(TestMyException.java:34)