Java異常學習

NO.1 簡單異常演示
public static void main (String[] args) {
        //Java異常學習--Exception
        /**
         * * A:JVM默認是如何處理異常的
         * main函數收到這個問題時,有兩種處理方式:
         * a:自己將該問題處理,然后繼續運行
         * b:自己沒有針對的處理方式,只有交給調用main的jvm來處理
         * jvm有一個默認的異常處理機制,就將該異常進行處理.
         * 并將該異常的名稱,異常的信息.異常出現的位置打印在了控制臺上,同時將程序停止運行
         * B:案例演示
         * JVM默認如何處理異常
         */

     Demo3 d = new Demo3();
    // int x = d.div(10,2);
   //這樣正常調用是沒問題的
        int x = d.div(10,0);
        //我們讓除數為0.就會拋出異常
        System.out.println(x);//java.lang.ArithmeticException
       //以后我們看錯誤從后往前看，先來到出錯的每一行，最后看運行時異常
    }

}
class  Demo3 {
    public int div(int a, int b) {
        return a / b;
    }
}
NO.2 異常處理的方式
#第一種
public static void main (String[] args) {
        /**
         * * A:異常處理的兩種方式
         * a:try?catch?finally
         * try catch
         * try catch finally
         * try finally 
         * b:throws
         * B:try...catch處理異常的基本格式
         * try?catch?finally
         * C:案例演示
         * try...catch的方式處理1個異常

         try:用來檢測異常的
         catch:用來捕獲異常的
         finally:釋放資源

         世界上最真情的相依就是你在try我在catch,無論你發神馬脾氣,我都靜靜接受,默默處理
         當通過trycatch將問題處理了,程序會繼續執行
         */
      
            Demo2 d = new Demo2();
            try{
                int x = d.div(10, 0);
                System.out.println(x);
            }catch(ArithmeticException a) {     //ArithmeticException a = new ArithmeticException();
                System.out.println("出錯了,除數為零了");
            }
              //我們經過主動異常處理，就可以繼續執行程序了
              System.out.println("1111111111111111");
        }

    }
    class Demo2 {
        /*
         * 除法運算
         */
        public int div(int a,int b) {       //a = 10,b = 0
            return a / b;                   // 10 / 0  被除數是10,除數是0當除數是0的時候違背了算數運算法則,拋出異常
            //new ArithmeticException("/ by zero");
        }
    } 

#第二種
/**
     * * A:案例演示
     * try...catch的方式處理多個異常
     * JDK7以后處理多個異常的方式及注意事項
     * 
     * 安卓,客戶端開發,如何處理異常?try{}catch(Exception e){}
     * ee,服務端開發,一般都是底層開發,從底層向上拋
     * 
     * try后面如果跟多個catch,那么小的異常放前面,大的異常放后面,根據多態的原理,如果大的放前面,就會將所有的子類對象接收
     * 后面的catch就沒有意義了
     */
    public static void main(String[] args) {
        //demo1();
        int a = 10;
        int b = 0;
        int[] arr = {11,22,33,44,55};
        
        //JDK7如何處理多個異常
        try {
            System.out.println(a / b);
            System.out.println(arr[10]);
        } catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
            System.out.println("出錯了");
        } 
    }

    public static void demo1() {
        int a = 10;
        int b = 0;
        int[] arr = {11,22,33,44,55};
        
        try {
            System.out.println(a / b);
            System.out.println(arr[10]);
            arr = null;
            System.out.println(arr[0]);
        } catch (ArithmeticException e) {
            System.out.println("除數不能為零");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("索引越界了");
        } catch (Exception e) {             //Exception e = new NullPointerException();
            System.out.println("出錯了");
        }
        
        System.out.println("over");
    }
}
NO.3 編譯時異常和運行時異常的區別
//Java中的異常分為編譯期和運行期異常
        //寫個編譯期異常--編譯時異常可以理解為未雨綢繆異常
        //編譯時異常就是必須對其進行處理，不然編譯是不通過的
        //這個FileInputStream就是讀取文件的，現在在自動編譯的時候就報錯了。
        //因為我們這個文件路徑可能是錯誤的，就讀取不到，所以我們做下處理

        //運行時異常:就是程序員的代碼錯誤，需要程序員回來修改代碼

        try {
            FileInputStream stre = new FileInputStream("tmac.xxx");
        }catch (Exception e){

        }
NO.4 Throwable的幾個常見方法
/**
     * * A:Throwable的幾個常見方法
            * a:getMessage()
                * 獲取異常信息，返回字符串。
            * b:toString()
                * 獲取異常類名和異常信息，返回字符串。
            * c:printStackTrace()
                * 獲取異常類名和異常信息，以及異常出現在程序中的位置。返回值void。
        * B:案例演示
            * Throwable的幾個常見方法的基本使用
     */
    public static void main(String[] args) {
        try {
            System.out.println(1/0);
        } catch (Exception e) {         //Exception e = new ArithmeticException("/ by zero");
            //System.out.println(e.getMessage());       //獲取異常信息
            //System.out.println(e);        //調用toString方法,打印異常類名和異常信息
            e.printStackTrace();        //jvm默認就用這種方式處理異常
        }
    }
}
NO.5 throws拋出異常的處理方式
/**
     * * A:throws的方式處理異常
            * 定義功能方法時，需要把出現的問題暴露出來讓調用者去處理。
            * 那么就通過throws在方法上標識。
        * B:案例演示
            * 舉例分別演示編譯時異常和運行時異常的拋出
            * 編譯時異常的拋出必須對其進行處理
            * 運行時異常的拋出可以處理也可以不處理
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {
        Person p = new Person();
        p.setAge(-17);
        System.out.println(p.getAge());
    }

}

class Person {
    private String name;
    private int age;
    public Person() {
        super();
        
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) throws AgeOutOfBoundsException {
        if(age >0 && age <= 150) {
            this.age = age;
        }else {
            //Exception e = new Exception("年齡非法");
            //throw e;
            throw new AgeOutOfBoundsException("年齡非法");
        }
      }
    }
NO.6 finaly關鍵字的作用和特點
/**
     * * A:finally的特點
            * 被finally控制的語句體一定會執行
            * 特殊情況：在執行到finally之前jvm退出了(比如System.exit(0))
        * B:finally的作用
            * 用于釋放資源，在IO流操作和數據庫操作中會見到
        * C:案例演示
            * finally關鍵字的特點及作用
        *return語句相當于是方法的最后一口氣,那么在他將死之前會看一看有沒有finally幫其完成遺愿,如果有就將finally執行
        *后在徹底返回
     */
    public static void main(String[] args) {
        try {
            System.out.println(10/0);
        } catch (Exception e) {
            System.out.println("除數為零了");
            System.exit(0);                             //退出jvm虛擬機
            return;
        } finally {
            System.out.println("看看我執行了嗎");
        }
    }
NO.7 簡單面試題
//面試題
      //final,finally和finalize的區別
        //final:可以修飾類，不能被繼承，修飾方法，不能被重寫，修飾變量，只能賦值一次
        //finally:是try語句中的一個語句體，不能被單獨使用，用來釋放資源
        //finalize:是一個方法，當垃圾回收器確定存在對該對象的過多引用時，由該對象的垃圾回收器調用此方法

        //第二題:
        //問:如果catch里面有return語句，finally的代碼還會執行嗎？如果會，請問是在return前還是return后
        //答:是在return先建立返回路徑，然后執行finally語句，最后返回
        //看這個例子
        Test test = new Test();
       int num =  test.method();
        System.out.println(num);
    }
}

class Test {
  public  int method(){
        int x = 10;
        try{
            x = 20;
            System.out.println(1/0);
            return x;
        }catch (Exception e){
            x = 30;
            return x;
        }finally {
            x = 40;
            System.out.println("finally執行了嘛");
    //千萬不要在finally里面寫返回語句，因為finally的作用是釋放資源，是肯定執行的。如果在這里面寫了返回語句，那么try和catch的結果都會被改變          
      }
    }
}
最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容

  • 1 Log4j 1.1 什么是Log4j? Log4j是Apache的一個開源項目，通過使用Log4j，我...
    咿呀_Java閱讀 358評論 0贊 2
  • 1. Java基礎部分 基礎部分的順序：基本語法，類相關的語法，內部類的語法，繼承相關的語法，異常的語法，線程的語...
    子非魚_t_閱讀 31,740評論 18贊 399
  • Android 自定義View的各種姿勢1 Activity的顯示之ViewRootImpl詳解 Activity...
    passiontim閱讀 172,841評論 25贊 708
  • 我出生在東北一個小城市，考上大學后離開家到外地上學并且留在外地工作，很多年里我都在找尋一種叫做身份認同的狀態，比如...
    aqua36閱讀 283評論 0贊 0
  • #58號雕刻打卡Day32# 1.九點靠墻站 10分鐘 感受：站的時間也是身體排氣的過程，或打嗝或放屁，每每都是。...
    一然2016閱讀 138評論 0贊 0