【Java基础19_1】异常Exception

蔚落 2022-06-07 14:15 177阅读 0赞

> **概述**

*  异常就是程序运行过程中可能产生的问题。

> **异常继承体系**

![异常继承体系图解][ac424060691e94552e48be1554d7291e57630f441c55a-KtCl4T_fw658]

> **异常的分类**

1.  **严重性**问题：**用错误Error类表示**（一般不解决也没有能力解决）  
    
2.  **非严重**性问题：（用异常类**Exception**表示）  
    ①. 运行期异常：发生在程序**运行**过程中产生的问题，只要是RunTimeException或者RunTimeException的子类都是运行时产生的异常。  
    ②. 编译期异常：发生在程序**编译**时期产生的问题。除了RunTimeException都是编译期的异常，就是Exception的子类。  
    将以上类的**共性**向上抽取即有了**Throwable**父类。

> **编译期异常和运行期异常的区别**

*  **运行期**异常如果没有处理，程序是==可以执行==。
 *  **编译期**异常如果没有处理，程序是==不能执行==的。

> **JVM会对异常的处理**

1.  当产生异常后，JVM在进行处理的时候，首先会==停止程序==，直接结束JVM，因此有异常的语句的后面的代码**都不会执行**。
2.  将错误信息打印到控制台。
    
     *  由于JVM会停止整个程序，有时我们可能会需要让程序继续往下执行，显然JVM的操作不太符合需求。因此我们有时需要人为**自定义异常**的处理，这样一来异常处理后，代码就能继续往下执行。

> **Throwable的几个常见方法**

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String getMessage ( )</td> 
   <td>获取异常信息</td> 
  </tr> 
  <tr> 
   <td>String toString ( )</td> 
   <td>获取异常类名和异常信息</td> 
  </tr> 
  <tr> 
   <td>void printStackTrace ( )</td> 
   <td>获取异常类名和异常信息，以及异常出现在程序中的位置</td> 
  </tr> 
 </tbody> 
</table>

*  Exception作为Throwable的子类，也继承了同样的方法

> **异常处理的方式**

1.  使用**try…catch…finally语句** 处理异常

//try...catch完整格式
        try{
           //有可能发生异常的语句
        }catch(异常类型 变量名){
           //异常处理方式
        }finally{
           //始终要执行的代码，可以做一些收尾的工作,可省略
        }

*  **注意**：  
    
    
     *  **try**中的代码**越少越好**
     *  **catch**中**要做处理**，哪怕是一条输出语句也可以。( 不能将异常信息隐藏 )

**1.第一种格式**：针对**单个异常**的处理方式

try{
        //有可能发生异常的语句
        }catch(异常类型 变量名){
        //异常处理方式
        }

public class ExceptionDemo {
    
    public static void main(String[] args) {
    
        // 使用try...catch语句对异常进行一个处理
    
        int a = 4;
        int b = 0;
    
        try{
            // 可能产生问题的代码
            System.out.println(a/b);
            System.out.println("hello");
    
        }catch(ArithmeticException e) {
            // 对异常的处理方式
            System.out.println("我捕获到了异常了。。。。");
        }
    
        System.out.println("world");
    
    }
    
    }

**2. 第二种格式**： 针对**多个异常**的处理方式。

try{
     //可能产生问题的代码
    }catch(异常类型1 变量名) {
      //对异常类型1的处理
    }catch(异常类型2 变量名) {
      //对异常类型2的处理
    }catch(异常类型3 变量名) {
      //对异常类型3的处理
    }....

*  **注意事项**：  
    
    
     *  能明确的尽量明确到具体异常，**不要**轻易用相对当前异常较上级的**父类异常**来处理。
     *  平级关系的异常谁前谁后无所谓，如果出现了==父子关系==，==父异常必须在后面。==

//针对多个异常的处理方式
    public class ExceptionDemo {
    
    public static void main(String[] args) {
    
    int a = 4;
    int b = 1;
    int[] arr = {
       1,2,3,4,5};
    
    
    try {
        System.out.println(a/b);
        System.out.println(arr[2]);
        arr = null;
        System.out.println(arr[3]);
    
    }catch (ArrayIndexOutOfBoundsException e) {
        System.out.println("数组角标越界啦....");
    } 
    catch (ArithmeticException e) {
        System.out.println("除数为0了....");
    } catch (Exception e) {
        System.out.println("产生了异常了.....");
    }
    
    System.out.println("over");
    
    
    
    }
    
    }

**3. JDK1.7的新特性**：对**多个异常**的处理的**简化形式**

格式：
    try{
    //可能产生异常的代码
    }catch(异常类型1 | 异常类型2 | 异常类型3 | ...   变量名) {
    
    }
    
    注意事项:   
    1.处理方式是一致的。(实际开发中，好多时候可能就是针对同类型的问题，给出同一个处理)
    2.多个异常间必须是平级关系。

//对多个异常的处理的简化形式
    public class ExceptionDemo {
    
    public static void main(String[] args) {
    
    int a = 5;
    int b = 0;
    int[] arr = {};
    
    try{
        // System.out.println(a/b);
        System.out.println(arr[9]);
        arr = null;
        System.out.println(arr[2]);
    }catch(ArithmeticException | ArrayIndexOutOfBoundsException | NullPointerException e){
        System.out.println("产出异常了。。。。");
    }
    
    System.out.println("over");
    
    }
    
    }

> ##### **throws的方式处理异常 (理解)** #####

*  定义功能方法时，需要把出现的问题暴露出来让调用者去处理。那么就通过throws在方法上标识。
 *  throws表示的意思是：在该方法上声明出一个异常，表示该方法在调用的时候有可能产生该种异常。  
    语法：

public void add() throws 异常类型1,异常类型2..{
    
    }

*  如果上级或者所有的上级调用都没有处理该异常，异常会层级往上抛直到JVM处理异常，即停止整个程序。

> **throw的概述以及和throws的区别**

1.  **throws**：关键字，用在**方法的声明**上，用来表示该方法被调用的时候有可能会产生某些异常。格式：

throws 异常类型1 , 异常类型2 ,... {}

1.  **throw关键字**，用来在程序内部（方法中）抛出一个异常。表示的意思是实实在在的产生了一个异常，并抛出去。格式：

throw 异常对象;

public class ExceptionDemo {
    
    public static void main(String[] args) {
    
    //try { 
    // show(4, 0);
    //} catch (Exception e) { 
    // System.out.println("产生异常了。。。。");
    //}
    
       try {
        show(4,0);
       } catch (Exception e) {
        System.out.println("产生异常了。。。。");
       }
    
        System.out.println("over....");
    }
    
    public static void show(int a ,int b) throws ArithmeticException{
        if(b == 0) {
            // 如果b==0，那么执行a/b肯定会抛出一个异常
            // 手动的向外面抛出一个异常。
    // try { 
    // throw new ArithmeticException("除数为0了");
    // } catch (Exception e) { 
    // System.out.println("产生异常了。。。。");
    // }
            throw new ArithmeticException("除数为0了");
        } else {
            System.out.println(a/b);
        }
    
    }
    
    }

> **finally关键字**

1.  **特点**
    
     *  被finally控制的语句体**不管有没有异常**抛出**最终都会执行**
     *  **特殊情况**：在执行到finally之前jvm退出了(比如System.exit(0))，则finally才不会执行。
2.  作用
    
     *  用于**释放资源**，在IO流操作和数据库操作中会见到

> **有关finally的面试题**

1.  **final, finally**和**finalize**的区别？
    
     *  答：
     *  **final**是一个修饰符，修饰类，方法，变量。  
        
        
         *  修饰的**类**，不能被继承\*\*
         *  修饰的**方法**，不能**被子类重写**
         *  修饰的**变量**，本质上是一个**常量**。
         *  final如果修饰的是**引用数据类型**，指的对象的**地址值**不能发生改变；如果修饰的是**基本数据类型**，指的是基本数据类型**的值**不能发生改变
     *  **finally**：是一个关键字，用在try…catch语句中  
        
        
         *  特点：始终都会被执行
         *  作用：做一些收尾的工作，比如释放资源，释放数据库链接  
            
            
             *  **finalize**：是Object类中的一个方法，跟垃圾回收有关。当对象变成垃圾的时候，如果垃圾回收器正在回收这个对象，那么会调用该对象的finalize(); 相当于C++中的析构函数的作用。
2.  如果catch里面有return语句，请问finally的代码还会执行吗? 如果会，请问是在return前还是return后。
    
     *  答：会，在return之前执行。
3.  **try…catch…finally**的多种格式变形
    
     *  try \{ \} catch () \{ \}
     *  try \{ \} catch ( ) \{ \} finally \{ \}
     *  try \{ \} finally \{ \}

> **自定义异常**

*  自定义异常必须做到以下两点之一：
    
    1.  继承自Exception
    2.  继承自RuntimeException】
 *  [查看完整Demo][Demo]

/** * 分数不合法的异常类 * */
    public class ScoreInvalidateException extends RuntimeException{ 
    
    public ScoreInvalidateException() {
    super();
    }
    
    public ScoreInvalidateException(String message) {
    super(message);
    }

> **自定义异常小练习**

*  需求：从银行取钱，发现钱不够，给出提示。
 *  [查看参考答案][Link 1]

> **注意事项 ( 针对编译期异常 ) ( 了解 )**

1.  子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类,子类的方法也可以不抛出异常。(父亲坏了,儿子不能比父亲更坏)
2.  如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
3.  如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws(多线程会出现这个情况)

> **如何使用异常处理(了解)**

*  原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws
 *  区别:  
    
    
     *  后续程序需要继续运行就try
     *  后续程序不需要继续运行就throws

[ac424060691e94552e48be1554d7291e57630f441c55a-KtCl4T_fw658]: /images/20220607/33ed5f7221b04498b69737c2679e338f.png
[Demo]: http://note.youdao.com/noteshare?id=d44429337ea43ca59ce9a66624defcbf&sub=7284020398D0408C80F2874AEB78D017
[Link 1]: http://note.youdao.com/noteshare?id=efd6cfd90b01927b59f5f981611f1155&sub=4153361CEF4B407D99C504DF37BC210F