❶ 請問java程序在編譯和運行時有什麼區別，系統分別都會做什麼
Java程序的編譯
使用命令： javac *.java
編譯時，會將寫的.java文件（高級語言），生成相應的位元組碼文件.class文件（二進制代碼）
Java程序的執行
使用命令：java *
流程： 載入到 -- 連接 ---- 初始化 ...
運行時，首先會由將相應的.class文件，載入到內存中，並驗證.class文件的有效性，將相應類的Class載入到內存中，並對類中的靜態變數進行初始化操作，然後就由 主 類開始執行
具體的可以看一下 JVM 類載入過程，以及jVM的內存分配機制
❷ Java之運行時異常與編譯時異常區別
Java中用2種方法處理異常：
1.在發生異常的地方直接處理；
2.將異常拋給調用者,讓調用者處理。
Java常見的異常：
(1)編譯時異常:Java.lang.Exception
(2)運行期異常:Java.lang.RuntimeException
Java.lang.Exception和Java.lang.Error繼承自Java.lang.Throwable;
Java.lang.RuntimeException繼承自Java.lang.Exception.
編譯時異常：
程序正確，但因為外在的環境條件不滿足引發。例如：用戶錯誤及I/O問題----程序試圖打開一個並不存在的遠程Socket埠。這不是程序本身的邏輯錯誤，而很可能是遠程機器名字錯誤(用戶拼寫錯誤)。對商用軟體系統，程序開發者必須考慮並處理這個問題。Java編譯器強制要求處理這類異常，如果不捕獲這類異常，程序將不能被編譯。
運行期異常：
這意味著程序存在bug，如數組越界，0被除，入參不滿足規范.....這類異常需要更改程序來避免，Java編譯器強制要求處理這類異常。
❸ Java異常機制是什麼
一、異常的關鍵字：
一般來說，異常的關鍵字有：try、catch、finally、throw、throws。
網上的資料對這幾個關鍵字是這樣解釋的：
try： Opening exception-handling statement.
catch： Captures the exception.
finally： Runs its code before terminating the program.
throws: Lists the exceptions a method could throw.
Throw: Transfers control of the method to the exception handler.
try語句
try語句用大括弧{}指定了一段代碼，該段代碼可能會拋棄一個或多個例外。
catch語句
catch語句的參數類似於方法的聲明，包括一個例外類型和一個例外對象。例外類型必須為Throwable類的子類，它指明了catch語句所處理的例外類型，例外對象則由運行時系統在try所指定的代碼塊中生成並被捕獲，大括弧中包含對象的處理，其中可以調用對象的方法。
catch語句可以有多個，分別處理不同類的例外。Java運行時系統從上到下分別對每個catch語句處理的例外類型進行檢測，直到找到類型相匹配的catch語句為止。這里，類型匹配指catch所處理的例外類型與生成的例外對象的類型完全一致或者是它的父類，因此，catch語句的排列順序應該是從特殊到一般。也可以用一個catch語句處理多個例外類型，這時它的例外類型參數應該是這多個例外類型的父類，程序設計中要根據具體的情況來選擇catch語句的例外處理類型。
finally語句
try所限定的代碼中，當拋棄一個例外時，其後的代碼不會被執行。通過finally語句可以指定一塊代碼。無論try所指定的程序塊中拋棄或不拋棄例外，也無論catch語句的例外類型是否與所拋棄的例外的類型一致，finally所指定的代碼都要被執行，它提供了統一的出口。通常在finally語句中可以進行資源的清除工作。如關閉打開的文件等。
throws語句
throws總是出現在一個函數頭中，用來標明該成員函數可能拋出的各種異常。對大多數Exception子類來說，Java 編譯器會強迫你聲明在一個成員函數中拋出的異常的類型。如果異常的類型是Error或 RuntimeException， 或它們的子類，這個規則不起作用， 因為這在程序的正常部分中是不期待出現的。 如果你想明確地拋出一個RuntimeException，你必須用throws語句來聲明它的類型
throw語句
throw總是出現在函數體中，用來拋出一個異常。程序會在throw語句後立即終止，它後面的語句執行不到，然後在包含它的所有try塊中（可能在上層調用函數中）從里向外尋找含有與其匹配的catch子句的try塊。
其實，我個人覺得，簡單的來說：throws與throw從拼寫上只相差一個s，但是功能、作用上有很大的區別。throws用於在方法和類處聲明可能拋出的所有異常信息。throw而throw就是單個語句拋出異常，是指拋出的一個具體的異常類型，使用在方法（類）的內部。
如：
………………………………………………………………………………………………………
public class showUI throws Exception(){
public void tbstudy throws Exception(){
****;//
try{
/* 這里是要處理的異常 */
}
Catch(Exception of){
System.out.println(of);//列印出異常
}
}
｝
………………………………………………………………………………………………………
throws通常不用顯示的捕獲異常，可由系統自動將所有捕獲的異常信息拋給上級方法（即調用該方法或類的所有地方）；
throw則需要用戶自己捕獲相關的異常，而後再對其進行相關處理（如列印異常的地方，類型等），最後將處理後的異常信息拋出。
他們對異常處理方式也不同.throws對異常不處理,誰調用誰處理,throws的Exception的取值范圍要大於方法內部異常的最大范圍,而cathch的范圍又要大於throws的Exception的范圍;throw 主動拋出自定義異常類對象。
二、異常繼承體系
異常的繼承結構
三、java處理異常方式
在java代碼中如果發生異常，jvm（java虛擬機）會拋出異常對象，導致程序代碼中斷，這個時候jvm在做的操作就是：創建異常對象，然後拋出，比如：
1．int i= 1；
2．int j = 0；
3．int res = 0；
4．res = i/j；//除0錯誤
5．System.out.println(res);
這5句代碼運行到第四句會中斷，因為jvm拋出了異常
2.throw的作用：手動拋出異常。有時候有些錯誤在jvm看來不是錯誤，比如：
1. int age = 0;
2. age = -100;
3．System.out.println(age);
很正常的整形變數賦值，但是在我們眼中看來就不正常，誰的年齡會是負的呢？！所以我們需要自己手動引發異常，這就是throw的作用
int age = 0;
age = -100;
if(age<0){
Exception e = new Exception(); //創建異常對象
throw e; //拋出異常
}
System.out.println(age);
java中的異常機制
異常機制是指當程序出現錯誤後，程序如何處理。具體來說，異常機制提供了程序退出的安全通道。當出現錯誤後，程序執行的流程發生改變，程序的控制權轉移到異常處理器。
傳統的處理異常的辦法是，函數返回一個特殊的結果來表示出現異常（通常這個特殊結果是大家約定俗稱的），調用該函數的程序負責檢查並分析函數返回的結果。這樣做有如下的弊端：例如函數返回-1代表出現異常，但是如果函數確實要返回-1這個正確的值時就會出現混淆；可讀性降低，將程序代碼與處理異常的代碼混疊在一起；由調用函數的程序來分析錯誤，這就要求客戶程序員對庫函數有很深的了解。
在使用File類的方法時，如正在將U盤裡面的照片復制到電腦里時，有人將U盤拔掉了。這時我們的復製程序就會出錯，即拋出異常。當出現程序無法控制的外部環境問題（用戶提供的文件不存在或者創建文件時已有同名文件存在，文件內容損壞，網路不可用...）時，JAVA就會用異常對象來描述。
異常情況通常有三大類：
(1)檢查性異常:java.lang.Exception
(2)運行期異常:java.lang.RuntimeException
(3)錯誤:java.lang.Error
它們都是java.lang.Throwable類的子孫類。如右圖：
Throwable 類是 Java 語言中所有錯誤和異常類的父類，對於具體的異常，不應該使用Throwable類，而應該使用其他三者之一。
檢查性異常------程序正確，但因為外在的環境條件不滿足引發。例如：用戶錯誤及I/O問題----程序試圖打開一個並不存在的遠程Socket埠。這不是程序本身的邏輯錯誤，而很可能是遠程機器名字錯誤(用戶拼寫錯誤)。對商用軟體系統，程序開發者必須考慮並處理這個問題。JAVA編譯器強制要求處理這類異常，如果不捕獲這類異常，程序將不能被編譯。
運行期異常------這意味著程序存在bug，如數組越界，0被除，入參不滿足規范.....這類異常需要更改程序來避免，JAVA編譯器強制要求處理這類異常。用來表示設計或實現方面的問題，如數組越界等。因為設計和實現正確的程序不會引發這類異常，所以常常不處理它。發生這類異常時，運行時環境會輸出一條信息，提示用戶修正錯誤。
錯誤------一般很少見，也很難通過程序解決。它可能源於程序的bug，但一般更可能源於環境問題，如內存耗盡。錯誤在程序中無須處理，而有運行環境處理。Error表示很難恢復的錯誤，如內存越界。一般不期望用戶程序來處理，即使程序員有能力處理這種錯誤，也還是交給系統處理為好。
❹ 按異常在編譯時是否被檢測來分,異常可以分成哪兩種
檢查時異常（checkException）和運行時異常（runtime Exception）
❺ 請問如何理解Java中的異常機制
很久沒弄Java了，但裡面重要的東西我還是記得的，比如什麼面向對象的思想，繼承、封裝、多態。還是記得的，我不能說我Java學的如何如好，但基本的思想我理解的比較到位的。可能寫程序就要成問題了，光有思想史部行的，還要把思想運用到實際的程序中，那樣的話理解可能還要深刻些，每種技術，不論多麼簡單的技術還是要自己都練習練習才有可能取得比較好好的成績，而且還要經常練習才行，不要一種技術很久不練那可能等不到多久又忘了。
今天就來說說Java中的異常機制，Java中的異常分為運行時異常和錯誤、異常又分為受檢異常和非受檢異常，受檢異常就是有I/O操作的。裡面的東西如throw、throws等就不講了，咱主要講講如和理解，這些關鍵字大家順便找個書或者網站到處都能看到。錯誤就是在錯誤的時間、幹了錯誤的事。異常就是在正確的時間幹了錯誤的事，比如，你在你女朋友不在的時候看我她的日記，而她的日記又有一些以前不雅的東西，你看了，肯定會異常的，如果非受檢異常，能把這種異常隱藏到，說明Java是非受檢異常，這種異常你女朋友一眼就看出來了，如果是受檢異常，你女朋友可能先給提醒叫你不要動他的日記，看了可能你就有異常，在之前啦，你先聲明你可能會有異常，她可能才會讓你看。也不知道理解准不正確哈，反正，Java虛擬機和人其實是人的某些東西時一樣的。Java語言也是比較優秀的語言。
❻ java.lang.ExceptionInInitializerError 這個錯誤 怎麼解決
當在靜態初始化塊中出現了異常的時候，JVM會拋出 java.lang.ExceptionInInitializerError異常。如果你了解Java中的靜態變數，你會知道它們是在類載入的時候進行初始化的。如果在這個靜態變數初始化的過程中出現了異常，那麼就會拋出 java.lang.ExceptionInInitializerError異常。任何異常都可能會引發這種情況，比如說，java.lang.ArrayIndexOutOfBound或者java.lang.NullPointerException。Java開發人員通常會被這個錯誤弄暈，他覺得自己並沒有定義任何的靜態初始化塊，為什麼還會拋出ExceptionInInitializerError異常；事實上，Java默認會將靜態變數的初始化放在一個默認的靜態初始化塊中，然後按它們在源文件中聲明的順序來進行初始化。比如說變數ABC聲明在第一行，在第二行中使用到了，而在第三行的時候才初始化，那麼第二行的代碼會拋出一個NullPointerException異常，這個異常會被封裝到一個ExceptionInInitializerError異常中，如果這段代碼在主線程中執行了，你會看到控制台或者日誌文件中出現這樣的錯誤信息： "Exception in thread "main" java.lang.ExceptionInInitializerError"。在一個擁有大量日誌文件的大型系統中，這樣的錯誤很容易被忽略，而程序員會得到一個java.lang.NoClassDefFoundError異常。不幸的是只有當別人使用到了這個類的時候才會出現這個錯誤，因為ExceptionInInitializerError導致了這個類無法載入。由於類載入失敗了，因此JVM會拋出NoClassDefFoundError。有的時候這會誤導Java開發人員，他們會檢查類路徑，PATH,以及java.library.path看是不是缺少了這個類，卻又發現不了任何問題，這讓他們很困惑。如果你在分析NoClassDefFoundError的原因，你最好看下你的日誌文件中有沒有ExceptionInInitializerError，然後再考慮要不要檢查classpath。本文中我們將看到一段代碼，它會在靜態初始化過程中引發異常從而導致 "Exception in thread "main" java.lang.ExceptionInInitializerError"。在稍後的部分，我們將會看到如何去解決這個問題。
Exception in thread "main" java.lang.ExceptionInInitializerError的原因
正如別的錯誤或者異常一樣，當你看見這行信息，你知道這是出現ExceptionInInitializerError異常了，這個異常是由於類載入過程中靜態塊初始化過程失敗所導致的。由於它出現在負責啟動程序的主線程中，因此你最好從主類中開始分析，這里說的主類是指你在命令行參數中指定的那個，或者說是你聲明了public static void main(String args[])方法的那個類。如果你仔細地看一下完整的堆棧跟蹤信息，你其實什麼也不用做，因為JVM已經把類名給列印出來了，這就是引發ExceptionInInitializerError的類。ExceptionInInitializerError是LinkageError的子類，這意味著這個異常會導致你的類無法載入到JVM的內存中。現在我們來看一下這個示常式序，它在執行的時候會拋出下面的異常：
Exceptioninthread"main"java.lang.ExceptionInInitializerError
Causedby:java.lang.IndexOutOfBoundsException:Index:0,Size:0
atjava.util.ArrayList.rangeCheck(ArrayList.java:635)
atjava.util.ArrayList.get(ArrayList.java:411)
atStaticInitiazerDemo.<clinit>(StaticInitiazerDemo.java:15)
看一下棧跟蹤信息，你知道真正的異常是java.lang.IndexOutOfBoundsException,它在StaticInitiazerDemo的第二行被拋出來了。這是由於你調用了ArrayList的get()方法並傳入了位置0，而這個ArrayList的大小也是0（Index:0,Size:0）。看到這條信息後你知道當我們想從列表中取出第一張CreditCard時，這個列表是空的。
importjava.util.ArrayList;
importjava.util.List;
/**
*,whichcomes
*
*andinitialization.
*
*@authorJavinPaul
*/
{
privatestaticfinalList<CreditCard>cards=newArrayList<CreditCard>();
=cards.get(0);//1stcardisdefault
publicstaticbooleanisVisa="VISA".equalsIgnoreCase(prefferdCard.getNetwork());
publicstaticvoidmain(Stringargs[]){
makePayment(prefferdCard);
}
publicstaticvoidmakePayment(CreditCardcc){
if(isVisa){
//offer5%discount
}
//dectpayment
}
}
classCreditCard{
privatelongcard_number;//16digitcardnumber
privateintcvv;//3digitcvvnumber
privateintexpiryMonth;
privateintexpiryYear;
privateStringbank;
privateStringnetwork;
publicCreditCard(longcard_number,intcvv,intexpiryMonth,intexpiryYear,Stringbank,Stringnetwork){
super();
this.card_number=card_number;
this.cvv=cvv;
this.expiryMonth=expiryMonth;
this.expiryYear=expiryYear;
this.bank=bank;
this.network=network;
}
/**
*@returnthecard_number
*/
publicfinallonggetCard_number(){
returncard_number;
}
/**
*@returnthecvv
*/
publicfinalintgetCvv(){
returncvv;
}
/**
*@returntheexpiryMonth
*/
publicfinalintgetExpiryMonth(){
returnexpiryMonth;
}
/**
*@returntheexpiryYear
*/
publicfinalintgetExpiryYear(){
returnexpiryYear;
}
/**
*@returnthebank
*/
publicfinalStringgetBank(){
returnbank;
}
/**
*@returnthenetwork
*/
publicfinalStringgetNetwork(){
returnnetwork;
}
}
輸出：
Exceptioninthread"main"java.lang.ExceptionInInitializerError
Causedby:java.lang.IndexOutOfBoundsException:Index:0,Size:0
atjava.util.ArrayList.rangeCheck(UnknownSource)
atjava.util.ArrayList.get(UnknownSource)
atStaticInitializerDemo.<clinit>(StaticInitializerDemo.java:15)
這里是Java中所有Error類的類結構。你可以看到ExceptionInInitializerError是繼承自LinkageError的。還應當知道的是，像RuntimeException一樣，Error也是未檢查異常，編譯器是不去檢查有沒有相應的異常處理代碼的。
如何解決Exception in thread "main" java.lang.ExceptionInInitializerError
需要記住以下幾點：
1. "Exception in thread "main" java.lang.ExceptionInInitializerError"意味著異常出現在主線程，並且是LinkageError的一個子類java.lang.ExceptionInInitializerError，這是JVM類載入失敗時才拋出的，原因是靜態初始化代碼中出現了諸如IndexOutOfBoundsException或者NullPointerException這樣的RuntimeException。
2. 記住JVM會將所有的靜態變數的初始化按它們在源文件中的出現順序放到一個靜態初始化塊中。因此，不要覺得沒有看到靜態初始塊就認為不會出現這個異常。事實上，你得確保靜態變數的正確順序，比如說，如果 一個變數初始化的時候用到了另一個變數，你得確保這個變數在前面已經初始化過了。
3. 如果別的代碼想要使用這個類，則會拋出ExceptionInInitializerError異常，而它又會導致ClassNotFoundException或者NoClassDefFoundError。為什麼？因為這個類載入失敗了，並沒有載入到JVM的內存中。因此如果你在解決類不存在之類的異常時，先看看你的日誌文件中有沒有這個異常。
4. 記住靜態初始化代碼塊會拋出RuntimeException而不是已檢查異常，而後者需要有對應的catch塊來進行處理。
這就是關於Exception in thread "main" java.lang.ExceptionInInitializerError的所有東西了。你已經了解到了如何去跟蹤此類問題，並找出拋出這個異常的罪魁禍首。需要謹記的是這個異常的一個副作用是NoClassDefFoundError，而Java程序拋出這個異常的位置可能會離java.lang.ExceptionInInitializerError很遠，這取決於你的客戶端代碼何時引用到這個類。因此，在查看類路徑解決NoClassDefFoundError異常之前，最好先看看日誌有沒有出現ExceptionInInitializerError。
❼ java中異常的處理方法有哪兩種
1.檢查型異常,這樣的異常繼承於Excetpion,就是在編譯期間需要檢查,如果該異常被throw,那麼在該異常所在的method後必須顯示的throws,調用該method的地方也必須捕獲該異常,否則編譯器會拋出異常.ejb里的RemoteException是一個這樣的異常.來源：考試大
2.運行時異常,就是在運行期間系統出現的異常,該類異常繼承於RuntimeException,該類異常在編譯時系統不進行檢查,如NullPointerExcetpion,NumberFormatException.
3.系統錯誤,一般是JVM出現異常時拋出的異常,如OutofMemoryError,這樣的異常在J2EE開發中是不用關心的.考試大論壇
在J2EE開發中,檢查型異常被濫用以至於過一段時間程序員自己都看不懂拋出這樣的異常,.裡面封裝的這些錯誤信息是干什麼用的,更可怕的是有好多有用的信息找不到了.比如SQLException和RemoteException這樣的異常我們沒必要再進行封裝,這樣的異常只對我們調試程序有用,而對客戶來說它就是一個」系統錯誤」而已.異常處理有一個簡單的原則,你什麼時候需要封裝自己的檢查型異常?就是你很清楚自己拋出這個異常的用途時,比如用戶輸入用戶名和密碼要登錄,但用戶名和密碼不匹配,你就要定義一個檢查型異常,客戶端通過捕獲該異常,然後把相應的錯誤信息反饋給客戶.而其它的自己未預期的錯誤或者異常比如SQLException,只需封裝到EJBException中,ejb container會把它的信息追加到RemoteException里,這樣客戶端捕獲RemoteException後把它寫到系統日誌里,就很容易進行調試。
Java 異常的處理
在 Java 應用程序中，對異常的處理有兩種方式：處理異常和聲明異常。
處理異常：try、catch 和 finally
若要捕獲異常，則必須在代碼中添加異常處理器塊。這種 Java 結構可能包含 3 個部分，
都有 Java 關鍵字。下面的例子中使用了 try-catch-finally 代碼結構。
import java.io.*; public class EchoInputTryCatchFinally { public static void main（String args［］）{ System.out.println（」Enter text to echo：」）; InputStreamReader isr = new InputStreamReader（System.in）; BufferedReader inputReader = new BufferedReader（isr）; try{ String inputLine = inputReader.readLine（）; System.out.println（」Read：」 + inputLine）; } catch（IOException exc）{ System.out.println（」Exception encountered： 」 + exc）; } finally{ System.out.println（」End. 「）; } } 其中：
try 塊：將一個或者多個語句放入 try 時，則表示這些語句可能拋出異常。編譯器知道可能要發生異常，於是用一個特殊結構評估塊內所有語句。
catch 塊：當問題出現時，一種選擇是定義代碼塊來處理問題，catch 塊的目的便在於此。catch 塊是 try 塊所產生異常的接收者。基本原理是：一旦生成異常，則 try 塊的執行中止，JVM 將查找相應的 JVM。
finally 塊：還可以定義 finally 塊，無論運行 try 塊代碼的結果如何，該塊裡面的代碼一定運行。在常見的所有環境中，finally 塊都將運行。無論 try 塊是否運行完，無論是否產生異常，也無論是否在 catch 塊中得到處理，finally 塊都將執行。
try-catch-finally 規則：
必須在 try 之後添加 catch 或 finally 塊。try 塊後可同時接 catch 和 finally 塊，但至少有一個塊。
必須遵循塊順序：若代碼同時使用 catch 和 finally 塊，則必須將 catch 塊放在 try 塊之後。
catch 塊與相應的異常類的類型相關。
一個 try 塊可能有多個 catch 塊。若如此，則執行第一個匹配塊。
可嵌套 try-catch-finally 結構。
在 try-catch-finally 結構中，可重新拋出異常。
除了下列情況，總將執行 finally 做為結束：JVM 過早終止（調用 System.exit（int））；在 finally 塊中拋出一個未處理的異常；計算機斷電、失火、或遭遇病毒攻擊。
聲明異常
若要聲明異常，則必須將其添加到方法簽名塊的結束位置。下面是一個實例：
public void errorProneMethod（int input） throws java.io.IOException { //Code for the method，including one or more method //calls that may proce an IOException } 這樣，聲明的異常將傳給方法調用者，而且也通知了編譯器：該方法的任何調用者必須遵守處理或聲明規則。聲明異常的規則如下：
必須聲明方法可拋出的任何可檢測異常（checked exception）。
非檢測性異常（unchecked exception）不是必須的，可聲明，也可不聲明。
調用方法必須遵循任何可檢測異常的處理和聲明規則。若覆蓋一個方法，則不能聲明與覆蓋方法不同的異常。聲明的任何異常必須是被覆蓋方法所聲明異常的同類或子類。
❽ JAVA異常概念問題
1. RuntimeException是特殊的Exception，僅在java編譯器中起作用，也就是編譯器不要求程序必須捕捉。所以，RuntimeException可以自己定義，自己拋出，自己處理，也可以拋給虛擬機處理。
2. java程序中所有的異常都可以交給虛擬機來處理，虛擬機在捕捉到異常時，都是簡單的輸出異常，結束程序。
3. 同2所說的，所有的異常都可以交給虛擬機，自己定義的與系統自帶的沒有區別。
❾ java中自定義異常為何要繼承exception類
java.lang.Exception類是Java中所有異常的直接或間接父類。即Exception類是所有異常的根類。
1、異常的分類：
① 非運行時異常（Checked Exception）
② 運行時異常（Runtime Exception/Unchecked Exception）
public class Exception
extends Throwable
Exception 類及其子類是 Throwable 的一種形式，它指出了合理的應用程序想要捕獲的條件。
public class RuntimeException
extends Exception
RuntimeException 是那些可能在 Java 虛擬機正常運行期間拋出的異常的超類。
可能在執行方法期間拋出但未被捕獲的 RuntimeException 的任何子類都無需在 throws 子句中進行聲明。
a) RuntimeException類直接繼承自Exception類，稱為運行時異常。Java中所有的運行時異常都直接或間接的繼承自RuntimeException.
Java中所有的異常類都直接或間接的繼承自Exception。
2、異常的處理：
對應非運行時異常，必須對其進行處理。處理方式有兩種：
使用try…catch…finally語句塊進行捕獲
在產生異常的方法所在的方法聲明throws Exception
對於運行時異常，可以不對其進行處理，也可以對其進行處理。一般情況下都不對其進行處理。
3、捕獲異常：
try {
FileInputStream fs = new FileInputStream("D:/temp/a.txt");
} catch (FileNotFoundException e) {
System.out.println("catch...");
e.printStackTrace();
} finally{
System.out.println("finally...");
}
4、拋出和捕獲異常：
4.1、把異常交給JVM處理：
public class ExceptionTest {
public static void execute() throws Exception {
System.out.println("execute...");
throw new Exception();
}
public static void main(String[] args) throws Exception {
execute();
}
}
4.2、或者使用try catch語句塊捕獲異常：
public class ExceptionTest {
public static void execute() throws Exception {
System.out.println("execute...");
throw new Exception();
}
public static void main(String[] args) {
try {
execute();
} catch (Exception e1) {
e1.printStackTrace();
}
}
}
5、自定義異常：
自定義異常通常是定義一個繼承自Exception類的子類。一般情況下我們都會直接繼承自Exception類，而不會繼承某個運行時的異常類。
5.1、創建自定義異常：
public class MyException extends Exception{
public MyException(){
super();
}
public MyException(String msg){
super(msg);
}
}
5.2、在類中使用異常：
public class ExceptionTest {
public static void execute(String a) throws MyException {
System.out.println("execute...");
if("true".equals(a)){
throw new MyException("參數不能為 true");
}
}
}
5.3、捕獲自定義異常：
public static void main(String[] args) throws MyException {
execute("true");
}
6、異常使用注意事項：
當使用多個catch語句塊來捕獲異常時，需要將父類的catch語句塊放到子類型的catch塊之後，這樣才能保證後續的catch可能被執行，否則子類型的catch將永遠無法到達，Java編譯器會報編譯錯誤。
如果try語句塊中存在return語句，那麼首先會執行finally語句塊中的代碼，然後才返回。
如果try語句塊中存在System.exit(0)語句，那麼久不會執行finally語句塊的代碼了，因為System.exit(0)會終止當前運行的JVM。程序在JVM終止前結束執行。
❿ 用戶自定義異常類需要從以下哪個類繼承
java中的頂級內置類的java。 1ang。異常類型的Throwable
等都是它的子類;
其結構如下：
的Throwable
/ \
/ \
異常錯誤
/
/
的RuntimeException
例外，非運行時異常（通常Unreport的java ....異常未報告**異常），錯誤是一個災難性的錯誤，而不是程序本身可以通過最佳的系統處理控制，RuntimeException的是一個運行時異常（如被零除，程序本身不不要抱怨，但是當你運行上的錯誤）。對於例外情況可以點擊看非運行時嘗試{}
趕上（例外）{}
捕捉異常，但也可以在類名後拋出與拋出異常的異常，但拋出使用時拋出一個異常，如果有另一個類調用或繼承這個類，這仍然會有相同的異常類，然則用的try-catch不大，所以最好用的try-catch ，同時你還可以使用投擲扔，但比較麻煩，扔之間的區別拋出了：扔採用的是內部方法，這是在方法的定義拋出時，他告訴這個方法可能是編譯器發生異常，獨自拋出必須使用在try-catch，其次是拋出你不需要的方法的定義。