try-catch-finally的使用

/*
* 1、異常的處理：抓拋模型
*
* 過程一："拋"：程序在正常執行的過程當中，一旦出現異常，就會在異常代碼處生成一個對應異常類的對象。
* 並將此對象拋出。
* 一旦拋出對象之後，其後的代碼就再也不執行。
*
* 關於異常對象的產生：① 系統自動生成的異常對象
* ② 手動的生成一個異常對象，並拋出（throw）
*
* 過程二："抓"：能夠理解爲異常的處理方式：① try-catch-finally ② throws
*
*
* 2、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.ch.java1;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

import org.junit.Test;
public class ExceptionTest1 {
    
    
    @Test
    public void test2(){
        try{
            File file = new File("hello.txt");
            FileInputStream fis = new FileInputStream(file);
            
            int data = fis.read();
            while(data != -1){
                System.out.print((char)data);
                data = fis.read();
            }
            
            fis.close();
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
    
    @Test
    public void test1(){
        
        String str = "123";
        str = "abc";
        int num = 0;
        try{
            num = Integer.parseInt(str);
            
            System.out.println("hello-----1");
        }catch(NumberFormatException e){
//            System.out.println("出現數值轉換異常了，不要着急....");
            //String getMessage():
//            System.out.println(e.getMessage());
            //printStackTrace():
            e.printStackTrace();
        }catch(NullPointerException e){
            System.out.println("出現空指針異常了，不要着急....");
        }catch(Exception e){//父類異常聲明在最下面 System.out.println("出現異常了，不要着急....");
            
        }
        System.out.println(num);
        
        System.out.println("hello-----2");
    }
    
}

/*
* try-catch-finally中finally的使用：
*
*
* 1.finally是可選的
*
* 2.finally中聲明的是必定會被執行的代碼。即便catch中又出現異常了，try中有return語句，catch中有
* return語句等狀況。
*
* 3.像數據庫鏈接、輸入輸出流、網絡編程Socket等資源，JVM是不能自動的回收的，咱們須要本身手動的進行資源的
* 釋放。此時的資源釋放，就須要聲明在finally中。
*/

public class FinallyTest {
    
    
    @Test
    public void test2(){
        FileInputStream fis = null;
        try {
            File file = new File("hello1.txt");
            fis = new FileInputStream(file);
            
            int data = fis.read();
            while(data != -1){
                System.out.print((char)data);
                data = fis.read();
            }
            
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {// try-catch-finally結構能夠嵌套
                if(fis != null)
                    fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    
    @Test
    public void testMethod(){
        int num = method();
        System.out.println(num);
    }
    
    public int method(){
        
        try{
            int[] arr = new int[10];
            System.out.println(arr[10]);
            return 1;
        }catch(ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
            return 2;
        }finally{
            System.out.println("我必定會被執行");
            return 3;
        }
        
        
    }
    
    @Test
    public void test1(){
        try{
            int a = 10;
            int b = 0;
            System.out.println(a / b);
            
        }catch(ArithmeticException e){
            e.printStackTrace();
            
//            int[] arr = new int[10];
//            System.out.println(arr[10]);
            
        }catch(Exception e){
            e.printStackTrace();
        }
//        System.out.println("我好帥啊！！！~~");
        
        finally{
            System.out.println("我好帥啊~~");
        }
        
    }
    
}