Java_ 异常

引言：
本文主要写了Java有关异常的部分，从异常的分类开始介绍包括异常的产生、传递、两种常用的处理方式、自定义异常以及异常中面试题；

@[toc]

1. 异常概述

异常就是Java程序在运行过程中出现的特殊情况；

异常处理的必要性：

任何程序都可能存在大量的未知问题、错误；如果不对这些问题进行处理，可能导致程序的中断造成一定程度上的损失；

1.1 异常的分类

Throwable：可抛出的异常，一切错误异常的父类，在java.Lang包中。

只有当对象是此类或者子类之一的实例时，才能通过语句抛出。

Error：JVM、硬件、执行逻辑错误，一般不能手动处理,程序出现严重的问题(其他方式避免这种严重问题)

Exception：程序在运行和配置中产生的问题，开发者可以处理,Exception下面的所有异常都是平级关系

RuntimeException：运行时异常，代码不够严谨会存在安全隐患，可处理也可不处理，不处理就是JVM帮我们处理,打印堆栈跟踪信息；Eg：NullPointerException：空指针异常

CheckedException：受查异常，编译时期异常只要不是运行时发生的异常都属于编译时期异常，必须处理。Eg：parseException :解析异常

如果程序出现了问题，我们没有做任何处理，最终jvm会做出默认的处理，把异常的名称，原因及出现的问题等信息输出在控制台，同时结束程序；

public static void main(String[] args) {
   
        int a = 10;
        int b = 0;
        System.out.println(a/b);//java.lang.ArithmeticException: / by zero 除数不能为0    属于算数异常
        System.out.println("over");
    }

上述代码由于没有做任何处理，JVM将此异常打包成一个异常对象，抛给了main函数，main函数自己解决不了因此交给JVM，JVM在控制台输出java.lang.ArithmeticException: / by zero，异常信息并停止程序的执行；

1.2 Error 异常

public static void main(String[] args) {
   
   m1();
}
//程序当中--->error--->致命的（）
public static void m1() {
   
   int a = 20;
   int b = 30;

   m1();
}

Exception in thread "main" java.lang.StackOverflowError：栈内存溢出(不能手动处理也就是不能通过另外一段代码解决当前错误);

1.3 Exception 异常

public static void main(String[] args) {
   
        m6();
        //程序运行过程中的异常
    }
    // java.lang.ClassCastException类型转换异常
    public static void m1(){
   
        Object o = new Integer(2);
        Scanner sc = (Scanner)o;
    }
    // java.lang.ArithmeticException算数异常
    public static void m2(){
   
        System.out.println(10/0);
    }
     //java.lang.ArrayIndexOutOfBoundsException数组下标越界异常
    public static void m3() {
   
        int[] nums = new int[1];
        System.out.println(nums[1]);
    }
    // java.lang.StringIndexOutOfBoundsException字符串下标越界
    public static void m4() {
   
        String s = "wer";
        System.out.println(s.charAt(4));
    }
    // java.util.InputMismatchException输入错误异常
    public static void m5() {
   
        Scanner sc = new Scanner(System.in);
        System.out.println("输入数字：");
        int n = sc.nextInt();
    }
    // java.lang.NullPointerException空指针异常
    public static void m6() {
   
        Object o = null;
        o.hashCode();
    }

2. 异常的产生

自动抛出异常：当程序在运行时遇到不符合规范的代码或结果时，会产生异常；
手动抛出异常：语法:throw new 异常类型（”实际参数”）；
产生异常结果：相当于遇到了return语句，导致程序因异常而终止；

public class ThrowException {
   
    public static void main(String[] args) {
   
        Student stu = new Student();
        stu.setAge(145);
        System.out.println("年龄时：" +stu.getAge());
    }
}

class Student{
   
    private int age;
    public int getAge() {
   
        return this.age;
    }

    public void setAge(int age) {
   
        if(age > 0 && age <125){
   
            this.age = age;
        }else{
   
            //创建异常，单独存在就意味着仅是个对象
            RuntimeException re = new RuntimeException();
            //结合throw关键字，抛出异常
            throw re;
            //throw new RuntimeException();
        }
    }
}

在上述程序因为年龄输入不符合规范所以抛出异常，当产生异常相当于遇到了return语句使程序结束，在抛出异常时要结合throws关键字，可整合为 “throw new RuntimeException”；

3. 异常的传递

按照方法的调用链反向传递，如果始终没有处理异常，最终会由JVM进行默认异常处理（打印堆栈跟踪信息）

受查异常：throws声明异常，修饰在方法参数列表的后面（代码后飘红线）。
运行时异常：可处理也可不处理，无需声明异常。

public class TestTransferException {
   
    //打印堆栈跟踪信息
    public static void main(String[] args) throws Exception {
   
        System.out.println("main - start");
        m1(10);
        System.out.println("main - end");
    }
    public static void m1(int n) throws Exception{
   
        System.out.println("m1 - start");
        m2(n);
        System.out.println("m1 - end");
    }
    public static void m2(int n) throws Exception{
   
        System.out.println("m2 - start");
        m3(n);
        System.out.println("m2 - end");
    }
    //声明该方法可能存在受查异常
    public static void m3(int n) throws Exception{
   
        System.out.println("m3 - start");
        if(n % 2 ==0){
   
            throw new Exception();
        }
        System.out.println("m3 - end");
    }
}

传入奇数程序正常执行，当传入偶数在m3方法中抛出异常，属于受查异常，m3通过抛出异常向上面m2方法声明可能存在异常，m2传给m1直到有main方法传给JVM打印堆栈跟踪信息，按照方法的调用链反向传递；
运行时异常对程序没有影响，可以不声明；

4. Throwable 类

常用方法：

public String getMessage()：返回该错误的详细信息的字符串

public String toString()：返回一个对这个异常的简短描述

public void printStackTrace()：包含了getMessage()以及toString()，追踪到自己开发程序的某个行代码中以及涉及Java源码

public static void main(String[] args) {
       
    //给定一个字符串日期文本格式
    String s = "2020-6-25" ;
    //创建SimpleDateFormat对象
    try {
   
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd "); //JVM异常对象new ParseException()
        Date d = sdf.parse(s) ;
    }catch(ParseException e){
     //判断是否匹配,成功执行catch中语句(匹配成功)
        //返回该错误的详细信息的字符串
        String msg = e.getMessage() ;  
        System.out.println(msg);//Unparseable date: "2020-6-25"

        //返回一个对这个异常的简短描述 
        String strMsg = e.toString() ;
       System.out.println(strMsg);//java.text.ParseException: Unparseable date: "2020-6-25"

        //打印到标准错误流这个异常和回溯
        e.printStackTrace(); 
    }
    System.out.println("End");
}

创建SimpleDataFormat对象时故意多加一空格

5. 异常的处理方案

异常的处理：

try{}catch{}finally{}
throws

5.1 try...catch...finally... 格式

5.1.1 try...catch...

try{

可能出现异常的代码；

}catch(异常类名变量名){

异常处理相关代码

}

public static void main(String[] args) {
   
    int a = 10;
    int b = 0;
    //第一种try...catch...处理异常
    try{
   
        System.out.println(a/b);  
    }catch(ArithmeticException e){
   
        System.out.println("除数不能为0");//自定义处理
        //e.printStackTrace();//jvm处理
        System.out.println(e.getMessage());//获取异常的原因
    }
    System.out.println("over");
}

注：
- catch里面:处理异常,一旦出问题了,将异常信息打印控制台上
  - 自定义处理
  - JVM打印堆栈跟踪信息
  - 通过getMessage获取异常的原因
- try里面代码越少越好，防止加载过多代码冗余

5.1.2 多重Catch

try{

可能出现异常的代码；

}catch(异常类名1 变量名1){

异常处理相关代码

}catch(异常类名2 变量名2){

异常处理相关代码

}

......

public static void main(String[] args) {
   
        Scanner sc = new Scanner(System.in);
        try {
   
            System.out.println("请输入一个被除数");
            int num1 = sc.nextInt();

            System.out.println("请输入一个除数");
            int num2 = sc.nextInt();

            int result = num1 / num2;
            System.out.println(result);
        }catch(ArithmeticException e) {
   
            System.out.println("除数不能为0");
        }catch(InputMismatchException e) {
   
            System.out.println("请输入正确的整数");
        }catch(Exception e) {
   
            System.out.println("出现未知错误");
        }
            System.out.println("程序结束");    
    }
}

多重catch中如果有多个异常,并且存在异常父子关系的话,异常父类一定是在末尾,不能放在类的前面,遵循从子（小）到父（大）的顺序，父类异常在最后

5.1.3 try...catch...finally

try{

可能出现异常的代码；

}catch(异常类名变量名){

异常处理相关代码

}finally{

无论是否出现异常，都需要执行的代码结构，常用于释放资源

}

public static void main(String[] args) {
   
    Scanner sc = new Scanner(System.in);
    try{
   
        System.out.println("输入一个被除数：");
        int i1 = sc.nextInt();
        System.out.println("输入一个除数：");
        int i2 = sc.nextInt();

        int result = i1 / i2;
        System.out.println("结果为：" + result);
    }catch(ArithmeticException e){
   
        System.out.println("除数不能为0");
    }
    catch(InputMismatchException e){
   
        System.out.println("输入错误");
    }catch(Exception e){
   
        System.out.println("出现未知异常");
    }finally{
   
        System.out.println("End");
    }
}

5.1.4 JDK1.7之后

JDK7以后出现一种格式针对多个异常的处理

try{
 可能出现问题的代码
}catch(异常类名1 | 异常类名2 | ... 变量名){

处理异常

}

public static void main(String[] args) {
   
    int a = 10 ;
    int b = 0 ;
    int arr[] = {
   11,22,33} ;
    try {
   
        System.out.println(arr[3]);
        System.out.println(a/b);
    }catch(ArithmeticException | ArrayIndexOutOfBoundsException e) {
   
        System.out.println("除数不能为0");
        System.out.println("数组角标越界了");
    }
}

注：只能针对异常类名是同一种异常类型

4.1.5 try...catch... 的执行原理

当前程序进入到try语句中,一旦出问题了,就会通过JVM 虚拟机产生一个异常对象 new XXXException()内存中,然后进入到catch语句中判断JVM 产生的异常的实例是否是和catch语句中的异常类一样,如果一样执行catch语句中的代码；

4.1.6 try...catch相关的结构

try{}catch{}
try{}catch{}catch{}
try{}catch{}finally{}
try{}catch{}catch{}finally{}
try{}finally{}

5.2 throws抛出异常

throws:抛出在方法声明上表示出现异常的可能性

编译时期异常,如果在方法抛出异常了,调用者必须处理

运行时期异常调用者不需要处理

详见在第三个板块异常的传递部分

6. 自定义异常

需继承自Exception或Exception的子类，常用RuntimeException。

必要提供的构造方法：

无参构造方法
String message参数的构造方法

public class TestDefinedException {
   
    public static void main(String[] args) {
   
        Student stu = new Student();
        try {
   
            stu.setAge(250);//是可能出现异常的代码
        }catch(Exception e) {
   
            System.err.println(e.getMessage());//只获得报错的原因
        } 
        try {
   
            stu.setSex("nan");//受查异常编译时就报错要处理
        }catch(SexMismatchException se) {
   //捕获相应的类型
            System.err.println(se.getMessage());
        }catch(Exception e ) {
   
            e.printStackTrace();
        }
    }
}
//受查异常：需要声明出去
class SexMismatchException extends Exception{
   
    public SexMismatchException() {
   }
    public SexMismatchException(String message) {
   
        super(message);
    }
}

//运行时异常
class AgeInputException extends RuntimeException{
   

    public AgeInputException() {
   }//创建无异常原因信息的异常对象
    public AgeInputException(String message) {
   //编写异常原因信息
        super(message); //为message属性赋值。
    }
}
//自定义异常
class Student{
   
    private int age;//年龄
    private String sex;//性别  男  女

    public void setSex(String sex) throws SexMismatchException {
   
        if(sex.equals("男") || sex.equals("女")) {
   
            this.sex = sex;
        }else {
   
            //在用户输入一个性别后提醒。
            throw new SexMismatchException("性别输入的值为:“男”或“女”");
        }
    }
    public String getSex() {
   
        return this.sex;
    }
    public int getAge() {
   
        return this.age;
    }
    public void setAge(int age){
   
        if(age > 0 && age < 123) {
   
            this.age = age;
        }else {
   
            throw new AgeInputException("年龄的赋值应该在0岁到123岁之间"); //抛运行时异常的父类
        }
    }
}

7. 异常的注意事项

在继承关系中，如果父类中方法抛出了异常了，那么子类在重写父类该方法的时候，也必须抛出该异常，异常要么跟父类的方法一样，要么父类方法异常类的子类

如果父类中的方法抛出了多个异常,那么子类重写父类方法时候,抛出的异常一定是父类的异常或他的异常类的子类

父类中的方法如果没有抛出异常,那么子类在重写父类方法的时候,不能抛出(throws)异常只能try...catch...捕获异常

class Fu{
   
    public void show() throws Exception{
   }
    public void method(){
   }
}

class Zi extends Fu{
   
    public void show() throws ArithmeticException{
   }

    public void method(){
   
        String dataStr = "1200-12-07";
        //创建SimpleDataFormat解析日期文本格式
        try{
   
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date date = sdf.parse(dataStr) ;
            System.out.println(date);
        }catch (ParseException e) {
   
            e.printStackTrace();{
   
            }
        }
    }
}

8. 异常中的面试题

8.1 编译时期异常和运行时期异常的区别

编译时期异常:开发者必须处理的，编译通过不了；比如：NullPointerException:空指针(防止对象为null)

运行时期异常:代码不严谨,无需显示处理

public static void main(String[] args) {
   
    method() ;
}
private static void method() {
   
    //String:日期文本格式
    String s = "2020-6-18" ;
    //parse(String s) throws ParseException:解析  编译时期异常
    Date date = null ;

    try {
   
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;
        date = sdf.parse(s) ;
        //直接使用异常对象名.printStackTrace()
    } catch (ParseException e) {
   
        e.printStackTrace();
    }
    System.out.println(date);
}

编译时异常必须处理，通过try...catch

public static void main(String[] args) {
   
    //运行时期异常:开发者不需要显示处理
    int a = 10 ;
    int b = 0 ;    
    if(b!=0) {
   
        System.out.println(a/b);
    }else {
   
        System.out.println("除数不能0");
    }
}

运行时异常可以不处理直接交给JVM虚拟机处理，也可以加入逻辑判断处理；

8.2 关于throws和throw的区别

throws:

抛出在方法声明上,方法后面跟的是异常类名而且可以多个中间用逗号隔开

throws:表示抛出异常的可能性(可能会出现异常,可能不出现)

throws抛出的异常,交给调用者处理

throw：

抛出在方法体中,方法体中跟的是异常对象名 new XXxException()

throw:表单抛出异常的肯定性执行这段代码一定会出现异常

throw抛出的异常,交给了方法体中语句进行处理

throw 后面只能跟一个异常对象，一般时具体的异常对象

public static void main(String[] args) throws Exception {
   
    method() ;
    method2() ;
}

private static void method2() {
   
    int a = 10 ;
    int b = 0 ;
    if(b==0) {
   
        throw new ArithmeticException(); // 交给JVM将异常信息输出控制台上
    }else {
   
        System.out.println(a/b);
    }
}

private static void method() throws Exception {
   
    int a = 10 ;
    int b = 0 ;
    if(b==0) {
   
        throw new Exception() ; //不是明确的异常对象
    }else {
   
        System.out.println(a/b);
    }
}

8.3 final,finally,finalize之间的区别

final：

状态修饰符

修饰类,该类不能继承

修饰成员方法,该方法不能被重写

修饰成员变量,该变量---常量

finalize：

回收操作，跟Gc有关系垃圾回收器开启的时候回收没有更多引用的对象

finally：

是Java异常处理的一部分，只要不在执行finally语句前退出JVM那么其中的代码一定会执行，该部分主要去释放资源，如：流的资源，JDBC的数据库的链接对象

8.4 在try...catch...finally中,如果catch语句中有return语句的,finally一定会执行吗?在return之前还是之后？

是Java异常处理的一部分，只要不在执行finally语句前退出JVM那么其中的代码一定会执行，该部分主要去释放资源，如：流的资源，JDBC的数据库的链接对象

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

    private static int getInt(){
   
        int a = 10;
        int b = 0;

        try{
   
            a = 20;
            System.out.println(a/b);
        }catch(ArithmeticException e){
   
            a = 30;
            return a;//30 
        }finally{
   
            a = 40;
        }
        return a;
    }
}

try...catch...finally中，如果catch语句中有return语句的，finally一定会执行且是在return之前执行；
虽然走了finally但是没有返回值，所以输出30，在16行后面加上return a;那么返回的就是40；

Java有关异常的超详细笔记

Java_ 异常

1. 异常概述

1.1 异常的分类

1.2 Error 异常

1.3 Exception 异常

2. 异常的产生

3. 异常的传递

4. Throwable 类

5. 异常的处理方案

5.1 try...catch...finally... 格式

5.1.1 try...catch...

5.1.2 多重Catch

5.1.3 try...catch...finally

5.1.4 JDK1.7之后

4.1.5 try...catch... 的执行原理

4.1.6 try...catch相关的结构

5.2 throws抛出异常

6. 自定义异常

7. 异常的注意事项

8. 异常中的面试题

8.1 编译时期异常和运行时期异常的区别

8.2 关于throws和throw的区别

8.3 final,finally,finalize之间的区别

8.4 在try...catch...finally中,如果catch语句中有return语句的,finally一定会执行吗?在return之前还是之后？

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java有关异常的超详细笔记

Java_ 异常

1. 异常概述

1.1 异常的分类

1.2 Error 异常

1.3 Exception 异常

2. 异常的产生

3. 异常的传递

4. Throwable 类

5. 异常的处理方案

5.1 try...catch...finally... 格式

5.1.1 try...catch...

5.1.2 多重Catch

5.1.3 try...catch...finally

5.1.4 JDK1.7之后

4.1.5 try...catch... 的执行原理

4.1.6 try...catch相关的结构

5.2 throws抛出异常

6. 自定义异常

7. 异常的注意事项

8. 异常中的面试题

8.1 编译时期异常和运行时期异常的区别

8.2 关于throws和throw的区别

8.3 final,finally,finalize之间的区别

8.4 在try...catch...finally中,如果catch语句中有return语句的,finally一定会执行吗?在return之前还是之后？

热门文章

最新文章

相关课程

相关电子书

相关实验场景