欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Java零基礎(chǔ)講解異常

 更新時(shí)間:2022年04月25日 14:50:55   作者:厚積薄發(fā)?  
異常就是不正常,比如當(dāng)我們身體出現(xiàn)了異常我們會(huì)根據(jù)身體情況選擇喝開水、吃藥、看病、等?異常處理方法。?java異常處理機(jī)制是我們java語言使用異常處理機(jī)制為程序提供了錯(cuò)誤處理的能力,程序出現(xiàn)的錯(cuò)誤,程序可以安全的退出,以保證程序正常的運(yùn)行等

什么是異常?

異常在我們寫代碼是特別常見,因?yàn)槌绦騿T大部分時(shí)間都在修復(fù)bug,在java中通過throwable頂層類又可以分為兩個(gè),一個(gè)是Error(錯(cuò)誤),一個(gè)是Exception(異常)。

Error(錯(cuò)誤) : Error與異常不同的是,錯(cuò)誤并不能處理,而是程序員造成的問題,比如語法錯(cuò)誤那就要程序員檢查自己的語法,比如結(jié)果錯(cuò)誤(StackOverflowError和OutOfMemoryError

),那就要程序員檢查自己的邏輯。

Exception(異常) : 這個(gè)可以通過一些方式來處理,比如我們后面要講的throws(聲明異常),try{}catch{}(處理異常)這都是我們處理異常的方式,而異常又分為受查異常(編譯時(shí)異常)和非受查異常(運(yùn)行時(shí)異常RuntimeException)。

編譯時(shí)異常:程序不能通過編譯,就是編譯時(shí)異常,比如:clone時(shí)必須要通過throws來聲明異常

運(yùn)行時(shí)異常:指的是程序能通過編譯,但是運(yùn)行時(shí)出現(xiàn)異常。比如:NullPointerException、

ArrayIndexOutOfBoundsException、ArithmeticException。

以上的異常我們都能進(jìn)行處理解決,但是錯(cuò)誤需要程序員自己檢查代碼。

異常的處理

我們有兩種方式來來進(jìn)行處理:

一種是事前防御型:

boolean ret = false;
ret = 登陸游戲();
if (!ret) {
處理登陸游戲錯(cuò)誤;
return;
} r
et = 開始匹配();
if (!ret) {
處理匹配錯(cuò)誤;
return;
} r
et = 游戲確認(rèn)();
if (!ret) {
處理游戲確認(rèn)錯(cuò)誤;
return;
} r
et = 選擇英雄();
if (!ret) {
處理選擇英雄錯(cuò)誤;
return;
} r
et = 載入游戲畫面();
if (!ret) {
處理載入游戲錯(cuò)誤;
return;
} .
.....

事前防御型就是每一步都要檢查是否出現(xiàn)了錯(cuò)誤,這樣的缺點(diǎn)就是代碼顯得很混亂,效率低下;

一種是事后認(rèn)錯(cuò)型:

try {
登陸游戲();
開始匹配();
游戲確認(rèn)();
選擇英雄();
載入游戲畫面();
...
} catch (登陸游戲異常) {
處理登陸游戲異常;
} catch (開始匹配異常) {
處理開始匹配異常;
} catch (游戲確認(rèn)異常) {
處理游戲確認(rèn)異常;
} catch (選擇英雄異常) {
處理選擇英雄異常;
} catch (載入游戲畫面異常) {
處理載入游戲畫面異常;
} .
....

這種做法就是將所有代碼可能出現(xiàn)的異常全部放在try里,如果發(fā)現(xiàn)異常在進(jìn)行捕獲,這種就是先進(jìn)行操作遇到問題在進(jìn)行處理。

我們常常使用第二種trycatch這樣使代碼簡潔,清晰,效率更高。

異常的拋出

如果哪段代碼不符合你的預(yù)期,這段代碼我們就要拋出異常,java中我們通過關(guān)鍵字throw來拋出異常。

語法是  throw new 異常(你要拋出的異常)

public class TestDemo {
    public static void func(int a) {
        if(a==10) {
            throw new RuntimeException("a==10不符合預(yù)期,拋出這個(gè)異常");
        }
    }
    public static void main(String[] args) {
           func(10);
    }
}

看這段代碼:比如我們10這個(gè)數(shù)字不符合我們程序的預(yù)期,所以要拋出異常,我們就可以這樣跑出: throw new RuntimeException("a==10不符合預(yù)期,拋出這個(gè)異常");

處理異常

我們通常有兩種方式來處理異常,一種是通過throws聲明異常,一種是通過try{}catch{}通過try檢查代碼塊里是否有異常,如果有異常catch就進(jìn)行捕獲,如果沒有異常就正常下面的代碼。

throws聲明異常

語法:throws 異常,異常,異常......(可聲明多個(gè)異常)

public class TestDemo {
    public static void function(int[] array) {
        System.out.println(array[100]);
    }
    public static void main(String[] args) {
        int[] array = {7, 8, 9, 5, 6};
        function(array);
    }
}

大家都知道這里訪問100下標(biāo)是數(shù)組越界異常:

接下來通過throws來聲明異常:

還是會(huì)報(bào)錯(cuò)。

當(dāng)我們也給主函數(shù)聲明異常:

 答案依然會(huì)報(bào)錯(cuò)。

所以從這里我們得出了一個(gè)結(jié)論:通過throws只是告訴編譯器,這個(gè)方法可能會(huì)發(fā)生這個(gè)異常,只是聲明,但是并沒有進(jìn)行處理異常。我們還可以發(fā)現(xiàn),如果某一個(gè)方法出現(xiàn)了異常,那就會(huì)看這個(gè)方法有沒有處理異常,如果沒有處理就去看一看上層調(diào)用者有沒有處理異常。這里就是func只是聲明了異常,并沒有進(jìn)行處理異常,然后去上層調(diào)用者有沒有處理異常(也就是main方法)還是沒有處理異常,最后就交給JVM來處理進(jìn)行終止程序。聲明的異常必須是 Exception 或者 Exception 的子類。

那怎么進(jìn)行處理異常呢??  那就要通過我們接下來講解的try{}catch來進(jìn)行處理異常。

捕獲異常

try{

}catch(){

}

在Java我們利用try{}catch{}來處理異常;

語法:

    try{
     //可能發(fā)生異常的代碼
    }catch(異常 變量){//例如:ArrayIndexOutOfBoundsException(要捕獲的異常) e(變量)
      //如果try中的代碼拋出異常了,此處catch捕獲時(shí)異常類型與try中拋出的異常類型一致時(shí),
      //或者是try中拋出異常的基類時(shí),就會(huì)被捕獲到
      // 對(duì)異常就可以正常處理,處理完成后,跳出try-catch結(jié)構(gòu),繼續(xù)執(zhí)行后序代碼
    }finally{
      //此處代碼一定會(huì)執(zhí)行,用于資源清理掃尾等工作
    }

我們先來講一下try{}catch(){}

/*在方法中處理異常*/
public class TestDemo {
    public static void function(int[] array) throws ArrayIndexOutOfBoundsException {
        try{
            System.out.println(array[100]);
        }catch(ArrayIndexOutOfBoundsException e) {
            System.out.println("array[100]->數(shù)組下標(biāo)越界異常catch->捕獲成功");
        }
    }
    public static void main(String[] args) throws ArrayIndexOutOfBoundsException {
        int[] array = {7, 8, 9, 5, 6};
        function(array);
    }
}
/*在main方法中處理異常*/
public class TestDemo {
    public static void function(int[] array) throws ArrayIndexOutOfBoundsException {
            System.out.println(array[100]);
    }
    public static void main(String[] args) throws ArrayIndexOutOfBoundsException {
        int[] array = {7, 8, 9, 5, 6};
        try{
            function(array);
        }catch(ArrayIndexOutOfBoundsException e) {
            System.out.println("array[100]->數(shù)組下標(biāo)越界異常catch->捕獲成功");
        }
    }
}

我們使用try{}catch(){}就可以對(duì)異常進(jìn)行處理,既可以在方法中處理異常也可以在main方法中處理異常,同時(shí)這里throws雖然沒有什么用處,但是可以清晰的告訴程序員,這個(gè)方法未來可能會(huì)發(fā)生這個(gè)異常,所以還是有必要的。

try{}catch{}注意點(diǎn) 一:

當(dāng)捕獲異常成功的時(shí)候,后面的業(yè)務(wù)代碼正常執(zhí)行,如果沒有捕獲那就不會(huì)執(zhí)行。

try{}catch{}注意點(diǎn) 二:

 當(dāng)try里檢查到異常,catch就會(huì)捕獲,計(jì)算這個(gè)異常后面還有異常也不會(huì)執(zhí)行。

try{}catch{}注意點(diǎn)三:

throws只是聲明異常,并沒有處理異常,我們要通過try{}catch(){}來處理異常。

try{}catch{}注意點(diǎn)四:

 當(dāng)catch捕獲的異常類型與發(fā)生異常類型不符合,就不會(huì)被捕獲,就繼續(xù)往外拋異常知道JVM收到后終止程序

try{}catch{}注意點(diǎn)五:

 當(dāng)發(fā)生多種異常的時(shí)候,那就要多種catch來捕獲,多種異常,多次捕獲。

try{}catch{}注意點(diǎn)六:

 Exception是所有類的父類不能在前面捕獲,而是應(yīng)該放在最末尾進(jìn)行收尾工作。

既然Exception類是所對(duì)應(yīng)異常類的父類,那可不可以捕獲Exception,即多次異常,一次捕獲呢??

catch 進(jìn)行類型匹配的時(shí)候, 不光會(huì)匹配相同類型的異常對(duì)象, 也會(huì)捕捉目標(biāo)異常類型的子類對(duì)象

答案是不建議的。因?yàn)楫?dāng)代碼進(jìn)行復(fù)雜的時(shí)候,只捕獲Exception類并不知道究竟是什么處理出了問題。

打印異常信息

我們還可以利用printStackTrace來打印錯(cuò)誤信息。

finally:

finally經(jīng)常與try{}catch(){}進(jìn)行一起使用,finally主要是進(jìn)行資源的清理,的掃尾工作,且finally一定會(huì)被執(zhí)行。

我們來看這樣一段代碼結(jié)果會(huì)是什么??

public class TestDemo {
    public static int function(int[] array) throws ArrayIndexOutOfBoundsException {
        try {
            System.out.println(array[100]);
        }catch(ArrayIndexOutOfBoundsException e) {
            System.out.println("array[100]->數(shù)組下標(biāo)越界異常catch->捕獲成功");
            return -1;
        }finally{
            System.out.println("finally主要進(jìn)行資源回收和清理的掃尾工作~~~");
            return 9;
        }
    }
    public static void main(String[] args) throws ArrayIndexOutOfBoundsException,ArithmeticException {
        int[] array = {7, 8, 9, 5, 6};
        System.out.println(function(array));
        System.out.println("以下是業(yè)務(wù)代碼~~~~~~");
    }
}

 答案并不是我們想的return-1,執(zhí)行結(jié)束,而是return9,我們這里可以理解為finally的9將catch里的-1覆蓋。所以finally里面的代碼是一定會(huì)執(zhí)行的。

異常的處理流程

我的理解:

第一步檢查try里面的代碼里是否有異常,如果有異常catch就進(jìn)行捕獲,如果沒有異常接著往下執(zhí)行,這里catch如果沒有捕獲到就看一看上層調(diào)用者有沒有處理,有處理就進(jìn)行處理,沒有處理就交給JVM終止程序。如果catch捕獲到了,下面正常的業(yè)務(wù)代碼正常執(zhí)行。最后無論catch是否捕獲到了異常,finally里面的代碼都會(huì)執(zhí)行。

官方:

  • 程序先執(zhí)行 try 中的代碼
  • 如果 try 中的代碼出現(xiàn)異常, 就會(huì)結(jié)束 try 中的代碼, 看和 catch 中的異常類型是否匹配.
  • 如果找到匹配的異常類型, 就會(huì)執(zhí)行 catch 中的代碼
  • 如果沒有找到匹配的異常類型, 就會(huì)將異常向上傳遞到上層調(diào)用者.
  • 無論是否找到匹配的異常類型, finally 中的代碼都會(huì)被執(zhí)行到(在該方法結(jié)束之前執(zhí)行).
  • 如果上層調(diào)用者也沒有處理的了異常, 就繼續(xù)向上傳遞.
  • 一直到 main 方法也沒有合適的代碼處理異常, 就會(huì)交給 JVM 來進(jìn)行處理, 此時(shí)程序就會(huì)異常終止。

自定義異常

在我們做很大型的項(xiàng)目的時(shí)候,我們就會(huì)發(fā)現(xiàn),我們遇到的異常,在Java中的內(nèi)置異常并沒有,所以我們就需要自己定義一個(gè)異常,來維護(hù)我們實(shí)際中遇到的異常。

java 中雖然已經(jīng)內(nèi)置了豐富的異常類, 但是并不能完全表示實(shí)際開發(fā)中所遇到的一些異常,此時(shí)需要維護(hù)符合我們實(shí)際情況的異常結(jié)構(gòu)

在Java中自己聲明異常,不是說你寫了個(gè)異常的名字就是一個(gè)異常,而是在你自己定義的異常需要取繼承原有的內(nèi)置異常。

我們通過一個(gè)登陸的代碼來講解自定義異常:

class LogIn {
    private String name ="Admin";//用戶名
    private String password= "CsDn1263987..0";
    public void logInFor(String name,String password) throws UserNameErrorExecption, PasswordErrorException {
        if(!this.name.equals(name)){
            throw new UserNameErrorExecption("用戶名參數(shù)異常!?。?);
        }
        if(!this.password.equals(password)) {
            throw  new PasswordErrorException("用戶密碼參數(shù)異常?。。?);
        }
        System.out.println("~~~登陸成功~~~");
    }
}
public class TestDemo{
    public static void main(String[] args) throws UserNameErrorExecption, PasswordErrorException {
        LogIn logIn = new LogIn();
        //logIn.logInFor("Admin","CsDn1263987..0");
        try{
            logIn.logInFor("Admin","CsDn126398..0");
        }catch(UserNameErrorExecption nameError) {
            nameError.printStackTrace();
            System.out.println("用戶名錯(cuò)誤?。?!");
        }catch(PasswordErrorException passwordError) {
            passwordError.printStackTrace();
            System.out.println("密碼錯(cuò)誤?。?!");
        }
    }
}

自定義異常:

class PasswordError extends Exception {
     public PasswordError(String message) {
           super(message);
     }
}
class UserNameError extends Exception {
    public UserNameError(String message) {
        super(message);
    }
}

這就是我們定義的兩個(gè)異常。

通過繼承Exception來定義兩個(gè)異常。

一般我們自定義異常要繼承Exception或者是RunTimeException,定義其他的也可以。

  • 自定義異常通常會(huì)繼承自 Exception 或者 RuntimeException
  • 繼承自 Exception 的異常默認(rèn)是受查異常
  • 繼承自 RuntimeException 的異常默認(rèn)是非受查異常

到此這篇關(guān)于Java零基礎(chǔ)講解異常的文章就介紹到這了,更多相關(guān)Java異常內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家!

相關(guān)文章

最新評(píng)論