java语言中的异常的定义及使用

最新推荐文章于 2022-06-16 16:38:47 发布

呼哈呼

最新推荐文章于 2022-06-16 16:38:47 发布

阅读量464

点赞数 1

分类专栏： java基础文章标签： java

本文链接：https://blog.csdn.net/weixin_44771551/article/details/108207632

版权

java基础专栏收录该内容

46 篇文章 0 订阅

订阅专栏

java语言中的异常的定义及使用

（一）概念：

程序在运行过程中出现的特殊情况。

（二）异常的必要性：

任何程序都可能存在大量的未知问题、错误。
如果不对这些问题进行正确处理，则可能导致程序的中断，造成不必要的损失。

（三）异常的分类：

（1）运行时异常（非受检性异常），可处理，可不处理：

编译器不要求我们处理的异常，只有在运行的时候才会发生的异常，主要原因是编写程序的时候不够严谨，是需要避免的异常。

（2）检查时异常（受检性异常），必须处理：

1）抛出异常类型：throws

不知道如何处理异常的情况，把异常抛出，交由调用方处理，一旦出现异常，会终止程序。

2）捕获异常

在内部把异常处理，无需调用方处理，不管有没有发生异常程序照常运行。

3）抛出异常对象：throw

指定异常对象抛出，也会终止程序。

（四）常见的运行时异常：

异常	描述
NullPointerException	空指针异常
ArrayIndexOutOfBoundsException	数组越界异常
ClassCastException	类型转换异常
NumberFormatException	数字格式化异常
ArithmeticException	算术异常

1）空指针异常

String str = null;
System.out.println(str.equals(""));

2）数组越界异常

int[] nums = new int[3];
nums[3] = 10;

3）类型转换异常

Object x = new String("String");
System.out.println((Integer) x);

4）数字格式化异常

int num = Integer.parseInt("index");
System.out.println(num);

5）算术异常

int num = 10 / 0;
System.out.println(num);

（五）异常的处理：

Java的异常处理是通过5个关键字来实现的：

1）try：执行可能产生异常的代码。

2）catch：捕获异常，并处理。

3）finally：无论是否发生异常，代码总能执行。

4）throws：声明方法可能要抛出的各种异常。

5）throw：手动抛出异常。

（1）try…catch…

语法：
try {
//可能出现异常的代码
} catch(Exception e) {
//异常处理的相关代码，如：getMessage()、printStackTrace()
}

public class Main {
    public static void main(String[] args){
        try {
        	//一旦异常被引发，程序控制由try块转到catch块
            int a = 10 / 0;
            //所以这句话是永远不会执行的
            System.out.println("a的结果：" + a);
        } catch (ArithmeticException e) {
            System.out.println("算术异常！");
        }
        System.out.println("程序结束！");
    }
}
//输出结果：
//算术异常！
//程序结束！

（2）try…catch…finally…

语法：
try {
//可能出现异常的代码
} catch(Exception e) {
//异常处理的相关代码，如：getMessage()、printStackTrace()
} finally{
//是否发生异常都会执行，可以释放资源等。
}

public class Main {
    public static void main(String[] args){
        try {
            int a = 10 / 0;
            System.out.println("a的结果：" + a);
        } catch (ArithmeticException e) {
            System.out.println("算术异常！");
        } finally {
            System.out.println("有异常！");
        }
        System.out.println("程序结束！");
    }
}
//输出结果：
//算术异常！
//有异常！
//程序结束！

public class Demo03 {
    public static void main(String[] args) {
        System.out.println(test());
    }

    public static int test(){
        try{
            //终止虚拟机
            System.exit(1);
            return 1;
        }finally {
            //return 2;
            System.out.println("要return啦");
        }
    }
}
//只有这种情况不会执行finally

注：
1、finally块是否发生异常都执行；
2、finally块不执行的唯一情况是退出java虚拟机。

（3）多重catch

语法：
try{
//可能出现异常的代码。
}catch(异常类型1){
//满足异常类型1执行的相关代码。
}catch(异常类型2){
//满足异常类型2执行的相关代码。
}catch(异常类型3){
//满足异常类型3执行的相关代码
}

public class Main {
    public static void main(String[] args){
        try {
            int a = 10 / 0;
            System.out.println("a的结果：" + a);
        } catch (ArithmeticException e) {
            System.out.println("算术异常！");
        } catch (Exception e) {
            System.out.println("未知异常！");
        }
        System.out.println("程序结束！");
    }
}

注：
1、遵循从子( 小 )到父( 大 )的顺序，子类异常在前，父类异常在后；
2、发生异常时按顺序逐个匹配；
3、只执行第一个与异常类型匹配的catch语句。

（4）try…finally…

try…finally…不能捕获异常，仅仅用来当发生异常时，用来释放资源。
一般用在底层代码，只释放资源不做异常处理，把异常向上抛出。

语法：
try{
//可能出现异常的代码
}finally{
//是否发生异常都会执行，可以释放资源等
}

public class Main {
    public static void main(String[] args) {
        try {
            divide();
        } catch (Exception e) {
            System.out.println("出现异常:"+e.getMessage());
        }
    }
    public static void divide() {
        try {
            int a = 10/0;
            System.out.println("a的结果：" + a);
        } finally {
            System.out.println("释放资源！");
        }
        System.out.println("程序结束！");
    }
}

（5）声明异常：throws

public class Main {
    public static void main(String[] args) {
        try {
            divide();
        }catch (Exception e) {
            System.out.println("出现异常:"+e.getMessage());
        }
    }
    public static void divide() throws Exception {
        int a = 10/0;
        System.out.println("a的结果：" + a);
    }
}

（6）抛出异常：throw

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入姓名：");
        person.setName(sc.next());
        System.out.println("请输入性别：");
        person.setSex(sc.next());
        System.out.println("请输入年龄：");
        person.setAge(sc.nextInt());
        person.toString();
    }
}
class Person {
    private String name;
    private String sex;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        if(sex.equals("男") || sex.equals("女")) {
            this.sex = sex;
        }else {
            throw new RuntimeException("性别不符合要求！");
        }
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age > 0 && age <= 120) {
            this.age = age;
        }else {
            //抛出异常
            throw new RuntimeException("年龄不符合要求！");
        }
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", sex=" + sex + ", age=" + age + "]";
    }
}