day21异常处理&throw

qnmdlzg

已于 2022-02-16 20:18:31 修改

阅读量161

点赞数

CC 4.0 BY-SA版权

文章标签： java

于 2022-02-16 20:07:13 首次发布

本文链接：https://blog.youkuaiyun.com/qnmdlzg/article/details/122970217

异常：指的是程序出现不正常的情况

对应到java中异常的分类
java中的异常：Throwable
严重的问题：Error,我们不处理，这样的问题一般都是很严重的，比如说内存溢出（OOM）
问题：Exception（异常）
编译时期异常：除了RuntimeException都是编译时期异常，必须要处理，如果不处理，程序编译无法通过，无法运行。
运行时期异常：RuntimeException，这样的问题，一般情况下，我们不会对问题本身处理，因为这样的问题是自己在写代码过程中由于逻辑的不严谨导致的。

异常处理方案
1、try…catch…finally
2、throws

try...catch...finally的处理格式：
try{
可能会出现问题的代码
}catch(异常类名变量名){
针对出现问题后的处理代码
}finally{
只要是程序顺利进行，finally里面的内容无论如何都会执行
}

变形格式：
try{
可能会出现问题的代码
}catch(异常类名变量名){
针对出现问题后的处理代码
}

注意事项：
1、try里面的代码越少越好
2、catch必须要有内容，哪怕是一句简单的提示

package com.shujia.wyh.day21.exceptiondemo;

public class ExceptionDemo2 {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;

        try{
            System.out.println(a/b);
        }catch (ArithmeticException e){
            System.out.println("除数为0.。。。");
        }

        System.out.println("over");

    }
}

处理2个及两个以上的异常的情况
1) 每一个异常写一个try...catch
2) 写一个try,多个catch
try{
可能会出现问题的代码
}catch(异常类名1 变量1){
针对于异常1做的处理方案
}catch(异常类名2 变量2){
针对于异常2做的处理方案
}...
当处理多个异常使用第二种方案的时候需要注意的事项：
1、catch只能匹配对应的异常，并且只能匹配一个异常
2、平级关系的异常顺序无所谓，如果出现了父子继承关系，父类必须放在最后
3、try里面如果出错了，try中后面的代码不会执行，就会匹配catch中的异常，
匹配到后执行解决方案，后面的代码正常执行
4、catch中的异常类名，尽量明确，不要用大的异常去处理

package com.shujia.wyh.day21.exceptiondemo;

public class ExceptionDemo3 {
    public static void main(String[] args) {
//        fun1();
        fun2();

    }

    public static void fun2(){
        int a = 10;
        int b = 5;
        int[] arr ={1,2,3};

        try {
            System.out.println(a/b); //走到这里，报错了，try后面的代码不会继续执行，直接去匹配catch中的异常
            System.out.println(arr[4]);
        }catch (ArrayIndexOutOfBoundsException a1){//
            System.out.println("除数为0.。。");
        }catch (ArithmeticException a2){
            System.out.println("数组下标索引越界。。。。");
        }

        System.out.println("over3");

    }

    public static void fun1(){
        int a = 10;
        int b = 0;

        try{
            System.out.println(a/b);
        }catch (ArithmeticException e){
            System.out.println("除数为0.。。。");
        }

        System.out.println("over");

        System.out.println("==============================");
        int[] arr ={1,2,3};

        try {
            System.out.println(arr[4]); //ArrayIndexOutOfBoundsException
        }catch (ArrayIndexOutOfBoundsException q){
            System.out.println("数组下标越界。。");
        }

        System.out.println("over2");


    }

}

JDK1，7后出现的处理多个异常的方式：
try{
可能会出现问题的代码
}catch(ArrayIndexOutOfBoundsException | ArithmeticException | ...){
处理问题的方案
}

注意事项：
1、处理方式是一致的，这个方式虽然简洁，但是也不够好，针对多种数据类型的异常，只给出了一种解决方案
2、这样的方式，catch中只能写平级关系的异常类

package com.shujia.wyh.day21.exceptiondemo;

public class ExceptionDemo4 {
    public static void main(String[] args) {
        fun();
    }


    public static void fun() {
        int a = 10;
        int b = 5;
        int[] arr = {1, 2, 3};

        try {
            System.out.println(a / b);//走到这里，报错了，try后面的代码不会继续执行，直接去匹配catch中的异常
            System.out.println(arr[4]);
        }catch (ArrayIndexOutOfBoundsException|ArithmeticException e){
            System.out.println("出错了。。。。");
        }


        System.out.println("over3");
    }
}

编译时期异常与运行时时期异常的区别：
编译时期异常：Java程序必须要显示的处理，否则程序就会发生错误，无法通过编译，不能运行
运行时期异常：一般情况下，不去处理，修改代码逻辑，也可也和编译时期异常做一样的处理

package com.shujia.wyh.day21.exceptiondemo;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionDemo5 {
    public static void main(String[] args) {
        //日期转化
        String s = "2022-02-16 15";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        try{
            Date date = sdf.parse(s);
            System.out.println(date);
        }catch (ParseException e){
            System.out.println("日期转换异常");
        }

        System.out.println("over");

    }
}

Throwable中的方法

getMessage()
获取异常信息，返回字符串。
toString()
获取异常类名和异常信息，返回字符串。
返回此异常类名+": "+getLocalizedMessage()
而getLocalizedMessage()内部默认调用的是getMessage()
printStackTrace()
获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void

package com.shujia.wyh.day21.exceptiondemo;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionDemo6 {
    public static void main(String[] args) {
        //日期转化
        String s = "2022-02-16 15";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        try {
            Date date = sdf.parse(s);
            System.out.println(date);
        } catch (ParseException e) { //ParseException e = new ParseException();
//            String message = e.getMessage();
//            System.out.println(message); //Unparseable date: "2022-02-16 15"

//            String s1 = e.toString();
//            System.out.println(s1); //java.text.ParseException: Unparseable date: "2022-02-16 15"
            e.printStackTrace();
        }

        System.out.println("over");
    }
}

throws

定义功能方法时，需要把出现的问题暴露出来让调用者去处理。那么就通过throws在方法上标识

语句定义格式：
throws 异常类名
注意：
1、这个格式必须跟在方法的小括号后面，大括号的前面。
2、尽量不要在main方法上面抛出

总结：
1、编译时期异常抛出，将来调用者必须做处理
2、运行时期异常抛出，将来调用着依旧要做处理

package com.shujia.wyh.day21.exceptiondemo;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionDemo7 {
    public static void main(String[] args){
        System.out.println("今天天气真好");

        try {
            fun();
        }catch (ParseException p){
            p.printStackTrace();
        }

        try {
            fun2();
        }catch (ArithmeticException e){
            e.printStackTrace();
        }

        System.out.println("可以出去郊游");

    }

    public static void fun2() throws ArithmeticException{
        int a = 10;
        int b = 0;
        System.out.println(a/b);
    }


    public static void fun() throws ParseException {
        //日期转化
        String s = "2022-02-16 15";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = sdf.parse(s);
        System.out.println(date);
    }
}

throw:在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。
注意：此时用throw抛出的是异常类的对象

throws与throw的区别：
throws
用在方法声明后面，跟的是异常类名
可以跟多个异常类名，用逗号隔开
表示抛出异常，由该方法的调用者来处理
throws表示出现异常的一种可能性，并不一定会发生这些异常
throw
用在方法体内，跟的是异常对象名
只能抛出一个异常对象名
表示抛出异常，由方法体内的语句处理
throw则是抛出了异常，执行throw则一定抛出了某种异常

package com.shujia.wyh.day21.exceptiondemo;

import java.text.ParseException;

public class ExceptionDemo8 {
    public static void main(String[] args) {
        try {
            fun();
        }catch (ArithmeticException e){
            e.printStackTrace();
        }

        System.out.println("over");
    }

    public static void fun(){
        int a = 10;
        int b = 0;

        if(b==0){
            System.out.println("hello");
            throw new ArithmeticException();
        }else {
            System.out.println(a/b);
        }
    }
}

finally: 是属于处理异常try...catch..finally的一部分，一般是用于释放资源，正常情况下，都会执行，除非在执行finally之前，程序停止。

package com.shujia.wyh.day21.exceptiondemo;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class FinallyDemo1 {
    public static void main(String[] args) {
        //日期转化
        String s = "2022-02-16 16:";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        try {
            Date date = sdf.parse(s);
        }catch (ParseException e){
            e.printStackTrace();
        }finally {
            //一般情况下，finally里面写的是用于释放资源
            System.out.println("这里的代码一定会执行！");
        }

        System.out.println(date);

    }
}

final,finally和finalize的区别
final: 最终的意思，可以修饰类，成员变量，成员方法
修饰类：类不能被继承
修饰成员变量：变量变常量
修饰成员方法：方法不能被重写

finally: 是属于处理异常try...catch..finally的一部分，一般是用于释放资源，正常情况下，都会执行，
除非在执行finally之前，程序停止。

finalize: 是Object类中一个方法，是用于垃圾回收的，堆内存中的空间没有栈的引用指向它，但是什么时候回收我们不确定

如果catch里面有return语句，请问finally的代码还会执行吗? 会执行
如果会，请问是在return前还是return后? 在之间执行

package com.shujia.wyh.day21.exceptiondemo;

public class ExceptionDemo9 {
    public static void main(String[] args) {
        System.out.println(getInt()); // 30
    }

    public static int getInt() {
        int a = 10;
        try {
            System.out.println(a / 0);
            a = 20; //上面代码出错这里不执行
        } catch (ArithmeticException e) {
            a = 30; 
            return a; // 走到这里就已经生成了一个返回路径 a=30;
        } finally {
            a = 40; 
            System.out.println(a);
            return a; //40
        }

        return a; //30
    }
}