Java--异常/Exception--类型/原理

以你之姓@ 2022-08-28 03:53 193阅读 0赞

原文网址：[Java--异常/Exception--类型/原理\_IT利刃出鞘的博客-CSDN博客][Java--_Exception--_IT_-CSDN]

# 简介 #

**说明**

本文介绍Java的异常的类型及原理，以及各种try catch finally返回方式的执行结果。

# Java异常的层次结构 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70][]

Throwable有两个直接的子类: Error、Exception。

*  Error
    
     *  JVM内部的严重问题，比如资源不足等，无法恢复。
     *  处理方式: 程序员不用处理
 *  Exception
    
     *  JVM通过处理还可回到正常执行流程，即：可恢复。
     *  分RuntimeException和其他Exception，或者说分为非受检异常(unchecked exception)和受检异常(checked exception)。
        
         *  使用建议：将checked exceptions用于可恢复的情况，unchecked exception用于编程的错误。
            
             *  Use checked exceptions for recoverable conditions and runtime exceptions for programming errors (Item 58 in 2nd edition)
     *  RuntimeException（unchecked exception）
        
         *  处理或者不处理都可以（不需try...catch...或在方法声明时throws）
     *  其他Exception（checked exception）
        
         *  Java编译器要求程序必须捕获（try...catch）或声明抛出（方法声明时throws）这种异常。

**为什么要对unchecked异常和checked异常进行区分？**

编译器将检查你是否为所有的已检查异常提供了异常处理机制，比如说我们使用Class.forName()来查找给定的字符串的class对象的时候，如果没有为这个方法提供异常处理，编译是无法通过的。

![20201009182931702.png][]

# 捕获异常再抛出 #

注意：下边的异常中的打印要用System.err而不是System.out，不然会影响打印的顺序。

**实例1：包裹原异常再抛出**

package com.example.a;
    
    public class Demo {
        public static void main(String[] args) throws Exception {
            try {
                int i = 1 / 0;
            } catch (Exception e) {
                System.err.println("自己捕获到异常：" + e.getMessage());
                e.printStackTrace();
                System.err.println("自己打印异常结束");
                throw new Exception("自己抛出的异常", e);
            }finally {
                System.out.println("This is finally");
            }
        }
    }

执行结果

自己捕获到异常：/ by zero
    java.lang.ArithmeticException: / by zero
    	at com.example.a.Demo.main(Demo.java:6)
    自己打印异常结束
    Exception in thread "main" java.lang.Exception: 自己抛出的异常
    	at com.example.a.Demo.main(Demo.java:11)
    Caused by: java.lang.ArithmeticException: / by zero
    	at com.example.a.Demo.main(Demo.java:6)
    This is finally

**实例2：不包裹原异常再抛出**

package com.example.a;
    
    public class Demo {
        public static void main(String[] args) throws Exception {
            try {
                int i = 1 / 0;
            } catch (Exception e) {
                System.err.println("自己捕获到异常：" + e.getMessage());
                e.printStackTrace();
                System.err.println("自己打印异常结束");
                throw new Exception("自己抛出的异常");
            }finally {
                System.out.println("This is finally");
            }
        }
    }

执行结果

# try/catch/finally/return执行顺序 #

**总结**

1.  如果catch或者finally中有return，则catch和finally代码块之后的部分根本不会执行到。

## **正常用法（try异常，catch/finally无return）** ##

package org.example.a;
    
    public class Demo {
        public static void main(String[] args) {
            Object handler = handler();
            System.out.println(handler.toString());
        }
    
        public static Object handler() {
            try {
                System.out.println("try：内（前）");
                System.out.println("try：内（异常）" + 5 / 0);
                System.out.println("try：内（后）");
    
                return "try：返回";
            } catch (Exception e) {
                System.out.println("catch：内（前）");
    //            System.out.println("catch：内（异常）" + 5 / 0);
    //            System.out.println("catch：内（后）");
    //            return "catch：返回";
            } finally {
                System.out.println("finally：内");
    //            return "finally：返回";
            }
            System.out.println("最后");
            return "最后（返回）";
        }
    }

执行结果（try=> catch=> finally=> finally块之外）

try：内（前）
    catch：内（前）
    finally：内
    最后
    最后（返回）

## **try无异常，catch有return，finally无return** ##

package org.example.a;
    
    public class Demo {
        public static void main(String[] args) {
            Object handler = handler();
            System.out.println(handler.toString());
        }
    
        public static Object handler() {
            try {
                System.out.println("try：内（前）");
    //            System.out.println("try：内（异常）" + 5 / 0);
    //            System.out.println("try：内（后）");
    
                return "try：返回";
            } catch (Exception e) {
                System.out.println("catch：内（前）");
                System.out.println("catch：内（异常）" + 5 / 0);
                System.out.println("catch：内（后）");
    
                return "catch：返回";
            } finally {
                System.out.println("finally：内");
    //            return "finally：返回";
            }
        }
    }

执行结果（try=> finally=> try的return）

try：内（前）
    finally：内
    try：返回

## **try无异常，finally带return（Idea会报警告）** ##

package org.example.a;
    
    public class Demo {
        public static void main(String[] args) {
            Object handler = handler();
            System.out.println(handler.toString());
        }
    
        public static Object handler() {
            try {
                System.out.println("try：内（前）");
    //            System.out.println("try：内（异常）" + 5 / 0);
    //            System.out.println("try：内（后）");
    
                return "try：返回";
            } catch (Exception e) {
                System.out.println("catch：内（前）");
                System.out.println("catch：内（异常）" + 5 / 0);
                System.out.println("catch：内（后）");
    
                return "catch：返回";
            } finally {
                System.out.println("finally：内");
                return "finally：返回";
            }
        }
    }

执行结果（try=> finally=> 程序结束（不调用try的return））

try：内（前）
    finally：内
    finally：返回

## **try中异常（finally无return）** ##

package org.example.a;
    
    public class Demo {
        public static void main(String[] args) {
            Object handler = handler();
            System.out.println(handler.toString());
        }
    
        public static Object handler() {
            try {
                System.out.println("try：内（前）");
                System.out.println("try：内（异常）" + 5 / 0);
                System.out.println("try：内（后）");
    
                return "try：返回";
            } catch (Exception e) {
                System.out.println("catch：内（前）");
    //            System.out.println("catch：内（异常）" + 5 / 0);
    //            System.out.println("catch：内（后）");
    
                return "catch：返回";
            } finally {
                System.out.println("finally：内");
    //            return "finally：返回";
            }
        }
    }

执行结果（try=> catch=> finally=> catch的return）

try：内（前）
    catch：内（前）
    finally：内
    catch：返回

## **try中异常（finally有return）** ##

package org.example.a;
    
    public class Demo {
        public static void main(String[] args) {
            Object handler = handler();
            System.out.println(handler.toString());
        }
    
        public static Object handler() {
            try {
                System.out.println("try：内（前）");
                System.out.println("try：内（异常）" + 5 / 0);
                System.out.println("try：内（后）");
    
                return "try：返回";
            } catch (Exception e) {
                System.out.println("catch：内（前）");
    //            System.out.println("catch：内（异常）" + 5 / 0);
    //            System.out.println("catch：内（后）");
    
                return "catch：返回";
            } finally {
                System.out.println("finally：内");
                return "finally：返回";
            }
        }
    }

执行结果（try=> catch=> finally=> 程序退出）

try：内（前）
    catch：内（前）
    finally：内
    finally：返回

## **try异常，catch异常，finally无return** ##

package org.example.a;
    
    public class Demo {
        public static void main(String[] args) {
            Object handler = handler();
            System.out.println(handler.toString());
        }
    
        public static Object handler() {
            try {
                System.out.println("try：内（前）");
                System.out.println("try：内（异常）" + 5 / 0);
                System.out.println("try：内（后）");
    
                return "try：返回";
            } catch (Exception e) {
                System.out.println("catch：内（前）");
                System.out.println("catch：内（异常）" + 5 / 0);
                System.out.println("catch：内（后）");
    
                return "catch：返回";
            } finally {
                System.out.println("finally：内");
    //            return "finally：返回";
            }
        }
    }

执行结果（try=> catch=> finally=> 程序结束（catch不会再return））

Exception in thread "main" java.lang.ArithmeticException: / by zero
    	at org.example.a.Demo.handler(Demo.java:18)
    	at org.example.a.Demo.main(Demo.java:5)
    try：内（前）
    catch：内（前）
    finally：内

# 其他网址 #

[Java受检异常和非受检异常\_m0\_38095922的博客-CSDN博客][Java_m0_38095922_-CSDN]  
[01 受检异常和非受检异常的区别\_依剑行走天下的博客-CSDN博客][01 _-CSDN]  
[受检异常和非受检异常 - BigShen - 博客园][- BigShen -]

[Java--_Exception--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/120928271
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70]: /images/20220828/a94fe1d974a44366a9875ecf9212e81b.png
[20201009182931702.png]: /images/20220828/017d9a60a55b41629145713ea2b78db7.png
[Java_m0_38095922_-CSDN]: https://blog.csdn.net/m0_38095922/article/details/105504886
[01 _-CSDN]: https://blog.csdn.net/nonage_bread/article/details/114688860
[- BigShen -]: https://www.cnblogs.com/Qkxh320/p/batj_01_exception.html