什么是異常？

最簡單的，看一個(gè)代碼示例：

public static void main(String[] args) {
        int a = 1;
        int b = 0;
        System.out.println(a / b);
    }

這段代碼有什么問題？簡單，除數(shù)不能為0對(duì)吧，我們打印輸出：

顯而易見，程序出問題了，不能正常執(zhí)行了，這里出現(xiàn)了一些爆紅的信息，這些就是異常提示，這就是Java中提供的異常機(jī)制，當(dāng)你的程序存在問題的情況下，會(huì)給你打印輸出一些信息，這個(gè)就叫做異常信息。

字面意思上去理解，所謂“異?！币簿褪恰安徽！?，放在代碼程序中就是那些導(dǎo)致不能正確執(zhí)行的問題，比如上述代碼，Java就會(huì)給你打印出為啥此段代碼不能正確執(zhí)行，給你輸出不正常的信息，這樣你就可以根據(jù)異常信息去修改代碼，從而提高代碼的健壯性！

詳細(xì)聊聊異常

以上我們簡單看了下一個(gè)具體的異常，下面我們就“何為異?！痹僦卑椎奶接懸幌?，異常作為一種代碼的處理機(jī)制，現(xiàn)在基本上大多數(shù)的編程語言都包含有這個(gè)異常機(jī)制，但是，我門熟知的偉大的C語言是沒有異常處理機(jī)制的。

大多數(shù)的高級(jí)語言，比如Java，python，C++這些都包含非常完善的異常處理機(jī)制，既然有這個(gè)玩意，那自然有它的好處，一般來說吧，擁有異常機(jī)制可以是我們的代碼：

• 擁有更好的容錯(cuò)性
• 更加的健壯

那啥意思嘞？啥是容錯(cuò)性，啥又是健壯呢？

首先是容錯(cuò)性，這個(gè)通俗來講，就是可承受錯(cuò)誤的范圍和概率，比如說我們的程序要是沒有異常機(jī)制的話，那很多錯(cuò)誤是無法承受的，可能一旦出現(xiàn)錯(cuò)誤，就會(huì)導(dǎo)致我們的系統(tǒng)崩潰出大問題，這個(gè)帶來的后果可能比較嚴(yán)重，但是具有異常機(jī)制，就可以幫助我們?nèi)ヌ幚硪恍╁e(cuò)誤，以至于即使出現(xiàn)錯(cuò)誤也不會(huì)造成這么嚴(yán)重的后果。

那什么又是健壯呢？這個(gè)一般就是說我們的代碼比較安全，不容易出現(xiàn)bug，基本上把該想到的情況都想到了，代碼編寫比較嚴(yán)謹(jǐn)，不容易出錯(cuò)，質(zhì)量好，這個(gè)一般就可以說我們的代碼比較健壯。

當(dāng)然，以上只是我粗淺的理解，希望能夠幫助大家對(duì)異常機(jī)制的理解。

那再來說異常，其實(shí)就是不好的東西，比如我們的代碼有bug，程序出錯(cuò)等等，這些都是有可能發(fā)生的，誰也不能保證自己寫的代碼一定是正確的，對(duì)吧。

異常也就是代碼中可能出現(xiàn)的意外情況，這就要求我們?cè)诰帉懘a的時(shí)候盡量考慮全面，但是即使你考慮的再全面也不可能將所有的意外情況都考慮進(jìn)去，所以，實(shí)際當(dāng)中意外情況會(huì)有發(fā)生的概率，對(duì)于這種我們無法考慮周到的意外情況，就需要我們的異常機(jī)制去處理了。

Java中的異常

接下來我們來看看Java中的異常，想必大家多多少少都會(huì)聽說過這樣一個(gè)異常叫做空指針異常，我們來看代碼演示：

NullPointerException nullPointerException = new NullPointerException("空指針異常");
        System.out.println(nullPointerException);

可以發(fā)現(xiàn)，在Java真實(shí)存在NullPointerException這個(gè)類，而我們可以通過這個(gè)類去創(chuàng)建具體的異常對(duì)象，比如這里的空指針異常對(duì)象，我們打印輸出看看：

如此來看，在Java中，異常是以類的形式存在的，而且我們可以通過這些異常類去創(chuàng)建相應(yīng)的異常對(duì)象，那么我們?cè)賮砜催@段代碼：

public static void main(String[] args) {
        int a = 1;
        int b = 0;
        System.out.println(a / b);
    }

這里會(huì)出現(xiàn)異常，其實(shí)實(shí)際上就是在運(yùn)行到“ System.out.println(a / b);”的時(shí)候Jvm虛擬機(jī)就會(huì)在底層為我們創(chuàng)建出一個(gè)異常對(duì)象，從而將相關(guān)的異常信息打印輸出。

所以：

Java中異常是的的確確存在的類

Java的異常處理機(jī)制

接下來我們來說說Java的異常機(jī)制。我們還是來看上面那個(gè)代碼，也就是這個(gè)：

public static void main(String[] args) {
        int a = 1;
        int b = 0;
        System.out.println(a / b);
    }

這段代碼我們?nèi)绻\(yùn)行的話是會(huì)出錯(cuò)的，也就是這樣：

這里會(huì)給到我們一個(gè)異常信息，告訴我們說除數(shù)不能為0，然后程序就自動(dòng)退出了，接下來我們?cè)贋檫@段代碼添加一個(gè)打印輸出：

很顯然這里并不會(huì)執(zhí)行后面的這句輸出語句，因?yàn)榍懊嬉呀?jīng)出現(xiàn)異常程序退出了，但是如果我們要求這里的輸出必須執(zhí)行該怎么辦呢？

在Java中是提供了相對(duì)應(yīng)的異常處理機(jī)制的，以上在a/b的時(shí)候出現(xiàn)了異常，在Java中我們是可以通過如下的方式去捕獲到這個(gè)異常的。

try-catch捕獲異常

具體的操作就是使用try- catch去捕獲我們的異常并作出相應(yīng)處理，具體看代碼：

public static void main(String[] args) {

        int a = 1;
        int b = 0;
        try {
            System.out.println(a / b);
        } catch (Exception e) {
            System.out.println(e+"：除數(shù)不能為0！");
        }
        
        System.out.println("執(zhí)行到這里……");
        
    }

我們?cè)谥耙呀?jīng)說過，在Java中，異常是以類的形式存在的，在我們寫的程序代碼中，只要出現(xiàn)了異常，JVM就會(huì)給我們創(chuàng)建一個(gè)異常對(duì)象出來，這個(gè)時(shí)候，我們是需要對(duì)這個(gè)異常對(duì)象做處理的，如果你放任不管的話，最終導(dǎo)致的結(jié)果就是你的Java程序會(huì)退出。

所以啊，有異常你不處理，你的程序就會(huì)退出，那咋辦，處理啊，找到這個(gè)異常，處理它，那怎么找到呢？

我們可以使用try去包裹可能出現(xiàn)的異常代碼，比如上述所講的代碼，在執(zhí)行到a/b的時(shí)候可能出現(xiàn)異常，也就是b不能為0，這里簡單說下，這里的a和b是我們提前定義還好的，如果是讓用戶輸入a和b的值呢？

我們簡單改寫下代碼：

Scanner StringA = new Scanner(System.in);
        Scanner StringB = new Scanner(System.in);

        int a = Integer.parseInt(StringA.next());
        int b = Integer.parseInt(StringB.next());

        System.out.println(a/b);

        System.out.println("執(zhí)行到這里……");

這里的意思是我們從鍵盤輸入去獲取這個(gè)a和b，那么當(dāng)我們輸入的是這樣的a和b的時(shí)候執(zhí)行是沒什么問題的：

可是一旦用戶不小心把b的值輸成0，那么問題就來了：

所以這里繞了一圈就是告訴大家b/a這步操作是可能出現(xiàn)異常的，我們把這個(gè)操作叫做可能出現(xiàn)的異常代代碼塊，于是我們就可以使用try去操作這段代碼：

    try {
            System.out.println(a / b);
        } catch (Exception e) {
            System.out.println(e+"：除數(shù)不能為0！");
        }

這里要注意的就是，這個(gè)try和catch是一起配合使用的，catch是捕獲的意思，我們使用try包裹可能出現(xiàn)的異常代碼快，然后使用catch去捕獲這個(gè)異常對(duì)象，然后做出相應(yīng)的處理，比如這里，我們使用try包裹了a/b的操作，那么當(dāng)b不小心被賦值為零的時(shí)候，那么這里在運(yùn)行的時(shí)候就會(huì)出現(xiàn)異常，由于在Java中異常是以類的形式存在，所以這里會(huì)拋出一個(gè)異常對(duì)象。

那么我們仔細(xì)看這個(gè)catch后面有個(gè)括號(hào)，就是異常對(duì)象參數(shù)，意思就是如果出現(xiàn)的這個(gè)異常對(duì)象屬于我括號(hào)里的這個(gè)異常，那么就進(jìn)入這個(gè)catch塊去處理這個(gè)異常。

說白了就是，程序一旦出現(xiàn)異常，隨之而來就是會(huì)產(chǎn)生一個(gè)異常對(duì)象，而異常是以類的形式存在，那么你就得為這個(gè)異常對(duì)象定義一個(gè)catch塊，這個(gè)異常對(duì)象會(huì)根據(jù)catch后的參數(shù)去找屬于自己的那一個(gè)catch塊，找到就進(jìn)入該catch塊，沒有的話程序就有因?yàn)楫惓６K止了。

而除數(shù)為0這是一個(gè)叫做ArithmeticException的異常，也就是算術(shù)異常，而這個(gè)異常是繼承自Exception，也就是說Exception的范圍比ArithmeticException要大，所以Exception的catch塊可以處理身為子類的ArithmeticException異常。

異常類的繼承

以上我們說了ArithmeticException這個(gè)異常是繼承自Exception的，后者的范圍更廣，然后我們?cè)倏创a：

        try {
            System.out.println(a / b);
        } catch (ArithmeticException e) {
            System.out.println(e + "：除數(shù)不能為0！出現(xiàn)算術(shù)異常");
        } catch (Exception e) {
            System.out.println(e+"出現(xiàn)異常");
        }

也就是說，一個(gè)try下面可以對(duì)應(yīng)多個(gè)catch塊，而每一個(gè)catch都有自己對(duì)應(yīng)的一個(gè)可以處理的異常類型，我們看上面的改進(jìn)，我們添加了負(fù)責(zé)處理ArithmeticException的catch塊，那么結(jié)果是如呢？

可以看到，這里是直接進(jìn)入了ArithmeticException的catch塊，也就是說，異常對(duì)象一旦被一個(gè)catch捕獲，就不會(huì)再進(jìn)入下一個(gè)異常了。

有人可能會(huì)說可以這樣嗎？

也就是把Exception放在第一個(gè)catch塊，實(shí)際上這里是不行的，為啥？我們來看下再這里的一個(gè)異常繼承關(guān)系：

可以看到，ArithmeticException其實(shí)是Exception的子類的，如果你把Exception放在第一個(gè)catch塊的話那么所以的異常對(duì)象都將直接被這個(gè)catch塊捕獲，因?yàn)?strong>所有的異常對(duì)象都是Exception或者其子類的實(shí)例對(duì)象，這就很關(guān)鍵啊，意味著你后面定義再多的catch塊也沒有用啊，因?yàn)橛肋h(yuǎn)不會(huì)執(zhí)行到這里，上面已經(jīng)被Exception這個(gè)老大哥給截胡了，在Java中永遠(yuǎn)執(zhí)行不到的代碼就會(huì)被定義為錯(cuò)誤的，所以是不能把Exception給放到第一個(gè)catch塊的。

這里有這么一個(gè)原則：

先捕獲處理小范圍的異常，再捕獲處理大范圍的異常，也就是先小后大

意思也就是先把子類異常放在前面的catch塊，這么以來，Exception的捕獲基本上都是在最后一個(gè)catch了。

多異常的處理

這個(gè)是在Java 7之后增加的，也就是說啊在Java7之前嘞，一般來說一個(gè)catch塊只能捕獲處理一個(gè)異常，但是在Java7之后就升級(jí)了，可以一個(gè)catch塊捕獲處理多個(gè)異常。

那這個(gè)是怎么操作的呢？來看看代碼就一目了然了：

是不是還是比較清楚的，這里的編寫也很簡單，就是通過符號(hào)“｜”把不同的異常對(duì)象類型給分隔開，記住這里只需要在最后定一個(gè)異常就行，也就是這里的“e”，同時(shí)由于是捕獲多個(gè)異常，這里的e其實(shí)是默認(rèn)final修飾的，因此就不能再對(duì)e進(jìn)行任何賦值操作了，比如一下這樣就是錯(cuò)誤的：

這就是多個(gè)異常的捕獲了。

獲取異常信息

先明白這點(diǎn)：

當(dāng)產(chǎn)生一個(gè)異常對(duì)象，被相對(duì)應(yīng)的catch塊捕獲之后，這個(gè)catch塊后的異常形參變量也就接受到了這個(gè)異常對(duì)象。

因此，我們就可以通過這個(gè)異常參數(shù)去獲得一些異常信息，一般我們常用的一些方法如下：

• getMessage()：這個(gè)方法會(huì)返回異常的詳細(xì)描述信息
• printStackTrace()：這個(gè)方法會(huì)打印出異常的跟蹤棧信息
• printStackTrace(PrintStream p)：這個(gè)則會(huì)將異常的跟蹤棧信息輸出到指定的輸出流中去
• getgtacktreace()：返回異常的跟蹤站信息
  

那具體的訪問，我們看下代碼便知：

這里其實(shí)也比較簡單，就是幾個(gè)常見的異常信息獲取方法的使用。

finally

這個(gè)可以說叫做善后的，啥意思嘞？簡單來說，就是你的異常對(duì)象無論進(jìn)入哪個(gè)catch塊執(zhí)行，那么到最后這個(gè)finally里的代碼一定會(huì)被執(zhí)行。

這個(gè)一般用在哪里呢？通常被用于釋放資源，一般比如說數(shù)據(jù)庫連接操作，網(wǎng)絡(luò)連接或者常見的IO流的操作，這些就需要進(jìn)行資源的回收，那么這個(gè)時(shí)候就可以使用finally里，因?yàn)樗囟〞?huì)被執(zhí)行。

看到這里不知道大家有沒有疑惑啊，不是說Java會(huì)自動(dòng)回收資源嗎？這個(gè)感覺要手動(dòng)操作啊，這里其實(shí)你要區(qū)分資源的分類，Java的垃圾回收針對(duì)的堆內(nèi)存中的對(duì)象所占用的內(nèi)存，而這里說的IO流操作，數(shù)據(jù)庫連接什么都是屬于物理資源，而物理資源必須是需要手動(dòng)回收的。

看看代碼：

這個(gè)時(shí)候我們看異常的處理就比較完整了，也就是包括try，然后是catch，再加上一定會(huì)被執(zhí)行的finally塊。

那么這里就需要特別說一下了：

對(duì)于異常處理來說，try塊是必須的，沒有try塊啥也不是，而catch和finally則不是必須的，但是，也必須選擇其一，也就是說，你不能只有個(gè)try，既沒有catch也沒有finally，然后就是注意catch塊了，可以有多個(gè)，但是要遵循“先小后大”的原則

接下來我們來看個(gè)測試，看代碼：

我們?cè)谶@里加入了return語句，一般來說吧，只要程序的方法中碰到了return，那么就會(huì)立即結(jié)束該方法，但是現(xiàn)在呢？我們看下結(jié)果：

這說明，finally語句一定會(huì)被執(zhí)行！另外再給大家說一個(gè)注意點(diǎn)：

如果你在finally中定義了return語句，那么這個(gè)將導(dǎo)致你在try中定義的return語句失效，所以記住一點(diǎn)，不要在finally中使用return哦。

到這里我們清楚了，對(duì)于finally語句來說是一定會(huì)被執(zhí)行的（其實(shí)有例外，比如你調(diào)用了System.exit(1)退出虛擬機(jī)），我們常在finally中去做釋放資源的操作，但是你有沒有發(fā)現(xiàn)，這樣的操作覺得比較麻煩😡，那有沒有簡單的一些做法呢？

其實(shí)在Java7中對(duì)這個(gè)try語句進(jìn)行了增強(qiáng)，可以讓我們不需要在finally中進(jìn)行資源的關(guān)閉操作，可以自動(dòng)幫我們關(guān)閉需要釋放的資源，但是這里有個(gè)前提就是你所需要關(guān)閉的資源類要么實(shí)現(xiàn)AutoCloseable接⼝，要么實(shí)現(xiàn)Closeable接⼝，實(shí)際上在Java7中幾乎把所有的資源類都進(jìn)行了改寫，主要就是都實(shí)現(xiàn)了AutoCloseable或者Closeable接⼝，可以讓其實(shí)現(xiàn)資源的自動(dòng)關(guān)閉，這些資源類一般就是文件IO的各種類，或者是JDBC的Connection接口等等。

那到了Java9之后又對(duì)這個(gè)try語句進(jìn)行了增強(qiáng)，在java7的改進(jìn)中你需要在try后的圓括號(hào)內(nèi)聲明并創(chuàng)建資源，到了Java9，你不需要這樣做了，只需要自動(dòng)關(guān)閉的資源有final修飾或者是有效的final即可，這里先盡做了解，后期會(huì)詳細(xì)探討。

Checked異常和Runtime異常

接下來我們來看看關(guān)于異常的分類，Java中的異?？梢苑譃閮蓚€(gè)大類：

• Checked異常
• Runtime異常

那怎么區(qū)分這兩類異常呢？所有的RuntimeException類及其⼦類的實(shí)例被稱為Runtime異常；不 是RuntimeException類及其⼦類的異常實(shí)例則被稱為Checked異常。

那對(duì)于Checked異常就是可檢查異常，也就是說在Java中認(rèn)為這種異常是可以被提前處理的，所以一旦出現(xiàn)這種異常你就得處理它，如果不處理它，那是編譯都無法通過的。

那怎么去處理這個(gè)Checked異常呢？我們前面也說了，可以使用try- catch的方式去捕獲處理異常，當(dāng)然，我們還有一種方式就是拋出異常，暫且不管，這個(gè)等會(huì)會(huì)講。

對(duì)于Runtime異常也就是運(yùn)行時(shí)異常了，這個(gè)我們不需要在編譯階段就處理它，如果要處理的話，可以使用try- catch，就比如上面我們一直演示的那個(gè)除數(shù)為0的案例。

throws

我們可以使用throws來聲明拋出異常，啥意思嘞，這個(gè)拋出異常咋回事？字面意思去理解，就是這個(gè)異常不管了，扔出去，對(duì)吧，拋出拋出，那如何扔出去呢？使用這個(gè)throws關(guān)鍵字即可。

也就是說當(dāng)你不知道該如何處理某一類型的異常的時(shí)候，你就可以選擇將該異常拋出，實(shí)際上拋出異常也不是說就不管異常了，而是將該異常交給上一級(jí)調(diào)用者去處理。如果一直往上拋出異常，最終就把這個(gè)燙手山芋交給了JVM，那JVM是怎么處理這個(gè)異常呢？

一般就是：

打印異常的跟蹤棧信息，并中止程序

下面我們來看下代碼：

我們這里在main方法上使用throws拋出了這個(gè)異常，那就是把這個(gè)異常扔給了我們的JVM，而JVM的處理上面也說了，我們看下結(jié)果：

打印出跟蹤棧信息，然后中止程序，這里其實(shí)是個(gè)運(yùn)行時(shí)異常，也就是Runtime異常，接下來我們看下對(duì)于Checked異常的拋出，我們首先編寫一段含有Checked異常的代碼，如下：

這里就會(huì)產(chǎn)生一個(gè)編譯時(shí)異常，那么IDEA給我們的提示可以用try/catch捕獲處理，當(dāng)然，也可以使用throws關(guān)鍵字拋出，我們這里將其拋出：

接下來我們?cè)趍ain方法中去調(diào)用這個(gè)方法：

發(fā)現(xiàn)了嗎？我們?cè)趍ain方法中調(diào)用它依然是需要處理出現(xiàn)的異常的，本身CheckedTest將異常拋出，就是希望由調(diào)用者去處理該異常，所以這里我們?cè)趍ain方法中去調(diào)用該方法的時(shí)候也要一并去處理該方法產(chǎn)生的異常，要不你繼續(xù)將其拋出交給JVM，要不使用try/catch捕獲！

Checked異常的限制

這里給大家看一個(gè)示例：

發(fā)現(xiàn)沒有，當(dāng)我們使用throws去拋出一個(gè)異常時(shí)，父類中的方法拋出一個(gè)異常，而其子類中重寫該父類拋出異常的方法的時(shí)候，重寫后的方法拋出的異常的范圍是不能比父類中方法拋出的異常的范圍大的，這句話可能有點(diǎn)繞，但是配合看圖應(yīng)該能明白什么意思。

這其實(shí)就是Checked異常所帶來的一個(gè)限制。

手動(dòng)拋出異常

以上我們使用throw是來拋出異常其實(shí)都是Java自動(dòng)幫我們?nèi)伋霎惓?duì)象的，除此之外，我們還可以自己手動(dòng)的去拋出異常，這里需要使用到的一個(gè)關(guān)鍵字叫做throw，注意這里是沒有s的，和以上我們說的throws是不一樣的。

想一下這里為什么要手動(dòng)拋出異常呢？因?yàn)楫惓１旧砭筒皇谴_定的，什么意思呢？就是同一件事情，在不同的人看來可能性質(zhì)就不一樣，比如你明天要外出，可是明天突然就下雨了，那么這個(gè)下雨對(duì)你來說就是一種異常，是你不想要的，但是對(duì)于那些尤為某種情況希望明天下雨的來說，這件事情就不是一件異常事件。

對(duì)應(yīng)到我們的程序中，異常也是要根據(jù)具體情況來定義的，因此這種異常是系統(tǒng)無法幫我們來判定的，這就需要我們自行去拋出異常。

具體就是使用throw來手動(dòng)拋出異常，怎么操作的看代碼：

try {
            //規(guī)定第一次輸入的值不能大于10，也就是這里的stringA不能大于10
            Scanner stringA = new Scanner(System.in);
            Scanner stringB = new Scanner(System.in);
            int a = Integer.parseInt(stringA.next());
            int b = Integer.parseInt(stringB.next());

            if (a > 10) {
                throw new Exception("輸入的第一個(gè)數(shù)字不能大于10");
            } else {
                System.out.println(a + b);
            }
        } catch (Exception e) {
    		System.out.println(e.getMessage());
            System.out.println("第一次輸入請(qǐng)輸入一個(gè)小于10的數(shù)字！");
        }

同樣的，當(dāng)你手動(dòng)的拋出一個(gè)異常的時(shí)候也是需要對(duì)這個(gè)異常進(jìn)行處理的，我們這里使用try/catch來捕獲處理該異常，看結(jié)果：

這里說一點(diǎn)，就是無論你是手動(dòng)拋出異常還是系統(tǒng)給我們拋出異常，在java中對(duì)異常的處理方式是不變的。也就是說碰到Checked異常，要不使用throws將其拋出，要么使用try/catch語句塊捕獲處理。

自定義異常

一般來說吧，我們不會(huì)去手動(dòng)拋出異常，當(dāng)然，這里說的異常指的是系統(tǒng)級(jí)別的異常，那除此之外，我們還可以自己自定義異常，代碼如下：

class MyException extends Exception {
    public MyException(){}

    public MyException(String msg) {
        super(msg);
    }
}

以上我們就自定義了一個(gè)異常，自定義異常我們需要注意以下兩點(diǎn)：

創(chuàng)建一個(gè)無參構(gòu)造器創(chuàng)建一個(gè)帶有字符串參數(shù)的有參構(gòu)造器

這里的字符串參數(shù)其實(shí)就是異常的具體描述信息，比如我們之前這樣定義一個(gè)異常：

一般的我們要是自定義異常的話最好就是有一個(gè)“見名知意”的程度，就是我看到你這個(gè)自定義異常類名，大概知道這是一個(gè)什么異常。

小結(jié)

以上我們就Java中的異常進(jìn)行了學(xué)習(xí)，不知道你發(fā)現(xiàn)沒有，我們對(duì)異常的學(xué)習(xí)其實(shí)主要就是在圍繞以下五個(gè)關(guān)鍵字：

trycatchfinallythrowsthrow

然后還有就是要注意Checked異常和Runtime異常，以上都是關(guān)于異常的基本知識(shí)，掌握這些，足以應(yīng)付我們?cè)谌粘９ぷ鲗W(xué)習(xí)中異常操作，至于更深層次的學(xué)習(xí)則需要我們?cè)趯?shí)際應(yīng)用的去不斷的探索了，關(guān)于Java中的異常，我們就先介紹到這里。

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

最新評(píng)論