JAVA学习笔记（十九）

异常

　　Java代码在运行时期发生的问题就是异常。

异常的继承体系

　　

　　查阅API发现Exception 类及其子类是 Throwable 的一种形式，它用来表示java程序中可能会产生的异常，并要求对产生的异常进行合理的异常处理。继续观察，我们可以发现Exception有继承关系，它的父类是Throwable。Throwable是Java 语言中所有错误或异常的超类，即祖宗类。

异常继承体系总结

　　Throwable: 它是所有错误与异常的超类（祖宗类）

　　|- Error 错误

　　|- Exception 编译期异常,进行编译JAVA程序时出现的问题

　　　　|- RuntimeException 运行期异常, JAVA程序运行过程中出现的问题　　

异常的产生过程

　　这是一个普通的数组下标越界异常的产生过程；

抛出异常throw

　　在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。

　　在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？

　　1,创建一个异常对象。封装一些提示信息(信息可以自己编写)。

　　2,需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。throw 异常对象；

　　throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

使用格式：

throw new 异常类名(参数)

例如：

package com.oracle.demo01;

public class ExceptionDemo2 {
/*
 * 异常：编译时期异常：只要调用了抛出异常的方法没有处理，就会编译失败
 *                         如果出现编译时期异常处理方式（try throws）
 *             运行时期异常：方法内部抛出异常是运行异常 new XXXXException
 *                             如果是运行异常，它不会编译失败，方法声明不需要throws，调用者不需要处理
 *                             一旦发生，不要处理，修改源代码，没有执行的意义
 *                     RuntimeException及其他的子类
 * */
    public static void main(String[] args) {
        //定义一个方法，计算圆的面积
            double area=getArea(0);
            System.out.println(area);
    }
        public static double getArea(double r) {
            if(r<=0) {
                throw new RuntimeException("传入的值不符合要求");
            }
            return Math.PI*r*r;
        }
}

声明异常throws

声明：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。

/*
     * throw 后边加的是异常对象
     * throws后边加的是异常类名，并写在方法声明上
     * 作用：告诉调用者此方法可能出现异常，需要处理
     * 
     * */
    public static int getArray(int[] arr) throws Exception{
        if(arr==null) {
            throw new Exception("你传进来的数组是空的");
        }
        if(arr.length<3) {
            throw new Exception("你传的数组长度太小了，请传三个以上");
        }
        int i=arr[3];
        return i;
    } 

捕获异常try…catch…finally

　　try：该代码块中编写可能产生异常的代码。

　　catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。

　　finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

　　捕获异常格式

/*
     * try{
     * 被监测的代码
     * 可能出现异常的代码
     * }catch(异常类名 变量名){
     * 异常处理方式
     * }finally{
     * 必须要执行的代码
     * }
     * 作用：try监测到了有异常发生，接收到一个异常对象，
     * 将异常对象抛给catch代码块处理，catch捕获到了这个异常对象，那么就执行处理方式代码
     * 
     * */

多catch情况下的顺序问题：

package com.oracle.demo01;

public class NullExceptionDemo {
/*
 * 多catch顺序问题
 * 1.如果异常是平级的情况下（没有继承关系）
 * NullPointerException
 *             extends RuntimeException
 * ArrayIndexOutOfBoundsException extends
 *             IndexOutOfBoundsException extends RuntimeException 
 * 顺序可以随便写
 * 2.如果有继承关系，要把小辈的放在前边，大辈放在后边
 * Exception 
 * NullPointerException
 * */
    public static void main(String[] args) {
            int[] arr= null;
            try {
            int i=getArray(arr);
            System.out.println(i);
            }catch(NullPointerException ex) {
                System.out.println(ex.getMessage());
                //打印传入的字符串
                ex.printStackTrace();
                //printStackTrace()打印的是完整的异常信息，类名+字符串+报错位置
            }catch(ArrayIndexOutOfBoundsException ex) {
                System.out.println(ex.toString());
                //打印的是完整异常类名+传入的字符串
            }finally {
                //finally经常用于释放资源
                System.out.println("fianlly必须要执行的代码");
            }
            System.out.println("GameOver");

    }
    public static int getArray(int[] arr) throws NullPointerException,ArrayIndexOutOfBoundsException{
        if(arr==null) {
            throw new NullPointerException("你传的数组为null");
        }
        if(arr.length<3) {
            throw new ArrayIndexOutOfBoundsException("你传的数组长度不够");
        }
        return arr[3];
            }
}

异常在方法重写中细节

package com.oracle.demo01;

public class OverideDemo {
    public static void main(String[] args) {
        
    }
}
/*
 * 当父类中有异常方法的时候
 * 子类集成父类重写这个方法的时候，注意以下几点：
 * 1.子类可以选择不抛出，但是如果子类选择抛出异常，那么抛出的异常类不得超过父类的异常
 *             可以是父类的异常，也可以是父类异常的子类
 * 2.假如父类方法中没有抛异常，子类重写这个方法也不可以抛出异常
 * 3.假如父类方法中没有抛异常，但是子类重写这个方法时，在方法中调用了抛出异常的方法，
 *             那么你只有一个选择，就是try catch处理这个异常，不能throws
 * */
class Fu{
    public void FuMethod() {
        
    }
}
class Zi extends Fu{
    public void FuMethod(){
        try {
        method();
        }catch(Exception e){}
    }
    public void method() {}
}

异常中的常用方法

　　getMessage方法：返回该异常的详细信息字符串，即异常提示信息

　　toString方法：返回该异常的名称与详细信息字符串

　　printStackTrace：在控制台输出该异常的名称与详细信息字符串、异常出现的代码位置

自定义异常

class MyException extends Exception{
    /*
    *为什么要定义构造函数，因为看到Java中的异常描述类中有提供对异常对象的初始化方法。
    */
    public MyException(){
        super();
    }
    public MyException(String message)    {
        super(message);// 如果自定义异常需要异常信息，可以通过调用父类的带有字符串参数的构造函数即可。
    }
}

继承Exception，必须要throws声明，一声明就告知调用者进行捕获，一旦问题处理了调用者的程序会继续执行。

继承RuntimeExcpetion,不需要throws声明的，这时调用是不需要编写捕获代码的，因为调用根本就不知道有问题。一旦发生NoAgeException，调用者程序会停掉，并有jvm将信息显示到屏幕，让调用者看到问题，修正代码。