Java学习心得之异常处理

一、异常的概念

异常指的是运行期出现错误，也就是当程序开始执行以后执行期出现的错误。

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)

方法声明的时候可以指明这个方法有可能会抛出的异常类型，使用throw抛出异常，声明方法后面有throws声明的可能出现的异常一定要去捕获。

二、异常分类

三、异常的捕获处理

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)