Java中的异常和处理详解及总结

Java中的异常

首先,在下图先看看异常之间的关系

异常的概念

什么是（现实生活中的）异常？

在回家的路上,见到老太太摔倒,扶了老太太.

什么是Java中的异常

1. 代码正常运行不会出问题，但是遇到意外，参数变量，不符合要求，发生意外，代码终止运行

2. 代码中的异常处理好了，代码就可以顺利的继续运行！

   初学者一般见到的几个异常

异常后面的代码执行布了,只有解决好异常后,才能执行下次
例如: 除法
java.lang.ArithmeticException: / by zero
空指针异常
java.lang.NullPointerException
数组索引越界
java.lang.ArrayIndexOutOfBoundsException:

一般出现异常,有两种情况可以解决:

1,抛出异常,给被人解决:

2,自己解决:

抛出异常:

语法结构：方法后面使用throws 需要抛出的异常类型.

看代码:

public class SimpleDateF {
    public static void main(String[] args) throws ParseException {   //抛出异常的写法
        Date date = new Date();
        SimpleDateFormat simpleDateF = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
        String f = simpleDateF.format(date);
        System.out.println(f);
        //自定义格式
        simpleDateF = new SimpleDateFormat("y年M月d天");
        String st = "2019年4月20日";
        Date p=simpleDateF.parse(st);  //抛出异常
        System.out.println(p);

     //   System.out.println(simpleDateF);

    }
}
这块代码异常  Date p=simpleDateF.parse(st);   抛出后可以正常运行
 simpleDateF = new SimpleDateFormat("y年M月d天");
        String st = "2019年4月20日";
        Date p=simpleDateF.parse(st);  //抛出异常
        System.out.println(p);

运行结果:

注: 抛出异常的注意事项：

①方法抛出运行时异常，在方法头可以不用抛出异常

②方法抛出编译时异常：方法必须处理异常，或者抛出同类异常，或者抛出异常该异常的父类类型异常

自己处理[捕获异常]

1. try-catch的语法结构及链式结构多异常处理方式语法：

try{

//可能产生异常的代码

}catch(捕获的异常类型 e){//e是形式参数

//该异常捕获之后要做的操作

}catch(捕获的异常类型 e){//e是形式参数

//该异常捕获之后要做的操作

}finally{

//异常发生之后一定会执行到的语句块：

//①流资源关闭②释放锁

}

代码实现:

public class Try_Finally {
    public static void main(String[] args) {
        try {  //可能出现异常的代码块
            int[] arr = {1, 2};
            System.out.println(5 / 0);
            System.out.println(arr[3]);
        } catch (java.lang.ArrayIndexOutOfBoundsException e) {     //一般都直接放父类,他会自动打出错误类型
            //()可能发生异常的类型  {},执行到这儿,相应的代码块,
            // 对应的进入,进入一个,其他就布进入,
            // 执行完毕,继续下面代码走
            System.out.println(e + "异常处理");
        } catch (java.lang.ArithmeticException e) {
            System.out.println(e+"异常都走了");
        } finally {       //结构一定会执行的代码块,一般作为释放
             System.out.println(55);
        }
    }
}

finally: 作为释放锁和关闭资源流, 2,在虚拟机没有关闭的情况下,都能执行到.
3.一般和try-catch 一起用. 处理异常后finally一定会执行到
一般不再finally写返回语句return语句,难于理解.

看代码理解:

public class Finally_ {
    public static void main(String[] args) {
       /*
        finally: 作为释放锁和关闭资源流,  2,在虚拟机没有关闭的情况下,都能执行到.
         3.一般和try-catch 一起用.   处理异常后finally一定会执行到
         一般不再finally写返回语句return语句,难于理解.
        */
       test_Finally();
        System.out.println(test_Finally());
    }

    static int test_Finally() {
        int a = 10;
        try {
            System.out.println(3 / 0);  //有异常,进入catch
            return a;
        } catch (Exception e) {  //处理完成,如果没有finally,返回11
            a = 11;
              return a;
        } finally {
            a = 22;      //上面有异常会进入catch处理,当处理好了一行 向下执行
            return a;
        }
    }
}

1. 顺序执行：进入异常捕获语句块

2. 如果产生异常，执行catch捕获，捕获到对应异常，并且对应catch后面的代码块

3. finally语句块一定会执行到：前提前面语句没有执行System.exit(0)退出虚拟机

获得异常信息的方式

异常捕获分析

a. 写多个捕获异常的语句块，链式结构捕获多异常，根据不同的异常，做不同的处理

b. 捕获异常可以写异常的父类，也可以捕获到对应子类的异常

c. catch(捕获的异常类型 e)捕获的异常实际捕获一个异常对象，该对象e可以在catch语句块直接使用

代码:

public class GetMs {
    public static void main(String[] args) {
        try {
            int[] arr = {11, 22};
            System.out.println(arr[5]);
        } catch (java.lang.ArrayIndexOutOfBoundsException e) {
            System.out.println(e);
            String gms = e.getMessage(); //获取异常
            System.out.println(gms);
            e.printStackTrace();
        //打印异常
        } finally {
            System.out.println("缓冲哈");
        }

    }
}