5.异常处理 - 异常处理机制一：try-catch-finally - 《JavaSE 学习》

快捷键：选中需要try的代码，Alt+Shift+Z ，然后点击Try/catch Block

/
一、异常的处理：抓抛模型

过程一：”抛”：程序在正常执行过程中，一旦出现异常，就会在异常代码处生成一个对象异常类的对象。
并将此对象抛出。
一旦抛出对象以后，其后的代码就不再执行。

关于异常对象的产生：①系统自动生成的异常对象
②手动的生成一个异常对象，并抛出（throw）

过程二：”抓”：可以理解为异常的处理方式：① try-catch-finally ②throws

二、try-catch-finally的使用

try{
//可能出现异常的代码

}catch(异常类型1 变量名1){
//处理异常的方式1
}catch(异常类型2 变量名2){
//处理异常的方式2
}catch(异常类型3 变量名3){
//处理异常的方式3
}
……
finally{
//一定会执行的代码
}

说明：
1.finally是可选的
2.使用try将可能出现异常的代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，
根据此对象的类型，去catch中进行匹配
3.一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常处理。一旦处理完成，就跳出当前
的try-catch结构（在没有写finally的情况下）。继续执行其后的代码
4.catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。
catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则报错
5.常用的异常对象处理的方式：① String getMessage() ② printStackTrace()
6.在try结构中声明的变量，出了try结构后，就不能再被调用
7.try-catch-finally结构可以相互嵌套
体会1：
使用try-catch-finally处理编译时异常，使得程序在编译时就不再报错，但是运行时仍可能报错。
相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。

体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。
针对于编译时异常，我们说一定要考虑异常的处理。
/

package com.atguigu.java1;
import org.junit.Test;
/*
 * 一、异常的处理：抓抛模型
 * 
 * 过程一："抛"：程序在正常执行过程中，一旦出现异常，就会在异常代码处生成一个对象异常类的对象。
 *                 并将此对象抛出。
 *                 一旦抛出对象以后，其后的代码就不再执行。
 * 
 * 过程二："抓"：可以理解为异常的处理方式：① try-catch-finally   ②throws
 * 
 * 
 * 二、try-catch-finally的使用
 * 
 * try{
 *         //可能出现异常的代码
 * 
 * }catch(异常类型1 变量名1){
 *         //处理异常的方式1
 * }catch(异常类型2 变量名2){
 *         //处理异常的方式2
 * }catch(异常类型3 变量名3){
 *         //处理异常的方式3
 * }
 * ......
 * finally{
 *         //一定会执行的代码
 * }
 * 
 * 说明：
 * 1.finally是可选的
 * 2.使用try将可能出现异常的代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，
 *      根据此对象的类型，去catch中进行匹配
 * 3.一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常处理。一旦处理完成，就跳出当前
 *   的try-catch结构（在没有写finally的情况下）。继续执行其后的代码
 * 4.catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。
 *   catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则报错
 * 5.常用的异常对象处理的方式：① String getMessage()   ② printStackTrace()
 * 6.在try结构中声明的变量，出了try结构后，就不能再被调用
 * 7.try-catch-finally结构可以相互嵌套
 * 体会1：
 *     使用try-catch-finally处理编译时异常，使得程序在编译时就不再报错，但是运行时仍可能报错。
 *     相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。
 *     
 * 体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。
 *          针对于编译时异常，我们说一定要考虑异常的处理。
 */
public class ExceptionTest1 {
    @Test
    public void test1() {
        String str = "123";
        str = "abc";
        try {
            int num = Integer.parseInt(str);
            System.out.println("hello-----1");
        } catch (NullPointerException e) {
            System.out.println("出现空指针异常了，不要着急....");
        } catch (NumberFormatException e) {
            System.out.println("出现数值转换异常了，不要着急....");
            System.out.println(e.getMessage());
            e.printStackTrace();
        } catch (Exception e) {
            System.out.println("出现异常了，不要着急....");
        }
        System.out.println("hello-----2");
    }
}

/
try-catch-finally中finally的使用：

1.finally时可选的

2.finally中声明的是一定会被执行的代码。即使catch中又出现异常了，try中有return语句，catch中有
return语句等情况。

3.像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己手动的b 进行资源的释放。此时的资源释放，就需要声明在finally中。

*/

package com.atguigu.java1;
import org.junit.Test;
/*
 * try-catch-finally中finally的使用：
 * 
 * 1.finally时可选的
 * 
 * 2.finally中声明的是一定会被执行的代码。即使catch中又出现异常了，try中有return语句，catch中有
 *  return语句等情况。
 *  
 * 3.像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己手动的进
 *  行资源的释放。此时的资源释放，就需要声明在finally中。
 * 
 */
public class FinallyTest {
    @Test
    public void test1(){
        try{
            int a = 10;
            int b = 0;
            System.out.println(a / b);
        }catch(ArithmeticException e){
            e.printStackTrace();    
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            System.out.println("我好水啊~~");
        }
    }
    @Test
    public void test2(){
    }
}