Java开发——20.异常

最新推荐文章于 2022-10-04 14:50:06 发布

小红的成长日记

最新推荐文章于 2022-10-04 14:50:06 发布

阅读量505

点赞数

分类专栏： JAVA 文章标签： java 开发语言 java-ee

本文链接：https://blog.csdn.net/weixin_46462532/article/details/124530951

版权

JAVA 专栏收录该内容

46 篇文章 0 订阅

订阅专栏

异常：

指的是程序在执行的过程中，出现的非正常的情况，最终会导致Java虚拟机(JVM)非正常停止。

在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

注意：异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行。

学习思路整理：

Throwable体系：

Error：严重错误Error，无法通过处理的错误，只能事先避免；

Exception：表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的；异常及时我们平时会遇到的。

异常的分类：

异常分为编译异常(非RuntimeException)和非编译异常(RuntimeException)；

编译异常：代码无法正确运行，进而无法生成.class的字节码文件，就好比静态方法中不能定义非静态变量…在使用Java开发工具时，会爆红导致编译不通过。

非编译异常：代码能正确运行，能生成对应的字节码文件，但是会在运行的时候报错，就好比我们平时会遇到的空指针异常…

异常处理：

1.把异常的名称，错误原因及异常出现的位置等信息输出在了控制台

2.程序停止执行

非编译异常(运行时异常)的处理方式：

抛异常throws：

(throws 异常名，将异常抛出并由java的虚拟机会对相关异常作出处理)；

捕获异常：

(try{可能存在的异常代码块;} catch(异常类类名){处理方法;})并手动处理；

两种不同的处理方式：

抛出异常代码展示：

public class test {

    public static void main(String[] args) {

        int a = 0;
        int b = 1;
        
        //除数不能为0，如果除数为0会报异常
        System.out.println(b/a);

    }

}

我在此处并没有，抛出异常，是底层Java的JVM帮我们判断处理的，Java的JVM会自动帮我们去找到该异常对应的异常类，并抛出异常；

抛异常并没有实际去解决异常，而是有Java的JVM去找到相关异常类并抛出，所以如果后期代码开发的过程中，遇到一些问题无法避免，可以抛出相关异常，让使用者留心，因为如果对接用户的话，会存在很多不确定性；

Java的DateFormat抽象类中的，SimpleDateFormat实现类中的parse()方法就有一个异常需要抛出；

//从给定字符串的开始解析文本以生成日期。该方法可能不会使用给定字符串的整个文本
public Date parse(String source)
           throws ParseException
           //ParseException - 如果指定字符串的开头不能被解析。

捕获异常代码展示：

try …catch异常：

 public static void main(String[] args) {

        try {

            int a = 0;
            int b = 1;
            System.out.println(b / a);

        }catch (ArithmeticException e){

            System.out.println("注意除数");

        }
    }

thorw关键字：

Java提供了一个throw关键字，它用来抛出一个指定的异常对象(可以使自定义的异常对象)；如下方法，就不能抛出一个Exception这个宽泛的异常。

指定抛出异常可能出现的问题：（异常不匹配）

throw和throws的区别：

1.throw代表动作,表示抛出一个异常的动作; throws代表一种状态,代表方法可能有异常抛出 ;

2.throw用在方法实现中,而throws用在方法声明中 ;

3.throw只能用于抛出一种指定的异常,而throws可以抛出多个异常；

关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常)。

自定义异常：

自定义异常就是在我们书写代码时无法避免的错误，在调用的时候给用户提醒的，自定义异常通常要继承自Exception/RuntimeException，在自定的时候可以参考Exception，底层就是继承Throwable。

一环接一环…：

自定义年龄异常类：

//定义Student类
public class Student {

    private String name;
    private String sex;
    private int age;

    public Student() {
    }

    public Student(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
}
}

定义年龄异常类(当年龄小于0，会爆出StudentAgeException异常，所以是运行是异常，继承自RuntimeException类)：

public class StudentAgeException extends RuntimeException{

    public StudentAgeException() {
        super();
    }
    public StudentAgeException(String mess) {
        super(mess);

    }
}

测试：

import cn.xiaozheng.pojo.Student;

public class StudentTest {

    public static void main(String[] args) {

        Student student = new Student();

        student.setAge(-2);

        if(student.getAge() < 0){
            throw new StudentAgeException("输入的年龄不能小于0");
        }

        System.out.println(student.getAge());
    }

}

注意：我们现在定义的异常，并不能使用try…catch抛出，因为我们的异常类中并没有定义引发异常抛出的条件，仅仅是为了预防某种已知的异常，所以只能使用相关判断+throw抛出指定的异常。

finally关键字：

在前面final关键字的学习的时候，引申了一个finally关键字，他用在try…catch中，表示无论是否有异常都会输出finally代码块中的内容；

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

正如上述图片上的异常，异常后的Sout代码并没有执行输出，finally就是为了解决在异常发生后仍要输出的内容就会放在finally块中。

比如后续要学习到的File类，不论是输入流还是输出流，在程序运行后必须要关闭流释放资源的，如果产生异常无法释放资源，导致Java内存溢出就会报错，所以finally是必须的。

fianlly定义格式：

//书写格式：
try {
  可能出现异常的代码;
      。。。
} catch(异常类名 变量名) {
  异常的处理代码;
} finally{
    释放资源
}

//注意事项
finally不能单独使用。必须配合着try...catch使用

代码演示：

public static void main(String[] args) {

        try {
            int num [] = {1,2,3};
            //num = null;
            System.out.println(num[2]);
        }catch (NullPointerException e){
        
            throw new NullPointerException();
            
        }finally {
        
            System.out.println("必须执行我！！！");
        }

        System.out.println("我是try...catch之外的内容");
    }

情景展示：

如果在try中直接return了，finally还会执行，是不会影响finally输出的。(在前期学习return关键字的时候，我们知道return是结束方法的，所以return之后是没有内容的。)

关于输出的顺序：finally是在return之前输出的，按原有意思解释可知return之后是没有内容输出的，所以return执行必定是最后了。

public class DemoFinally {

    public static void main(String[] args) {

        System.out.println(new DemoFinally().test());
    }
    
    //为了看出效果，我把原来的内容提到了方法之中，这样return就可以返回内容，直观的看到效果。
    public String test(){
        try {

            int num [] = {1,2,3};
            //num = null;
            System.out.println(num[2]);

            return "方法执行完毕！";

        }catch (NullPointerException e){

            throw new NullPointerException();

        }finally {

            System.out.println("必须执行我！！！");
        }
    }