❶ java中,如何進行異常處理
當程序違反了java語規則的時候,JAVA虛擬機就會將發生的錯誤表示為一個異常.這里語法規則指的是JAVA類庫內置的語義檢查.另一種情況就是JAVA允許程序員擴展這種語義檢查，程序員可以創建自己的異常，並自由選擇在何時用throw關鍵字引發異常。所有的異常都是Thowable的子類。 異常處理是與程序執行是並行的.Try{ //可能發現異常的語句塊}catch(異常類型,e){ //發生異常時候的執行語句塊} finnally{ //不管是否發生異常都執行的語句塊}
❷ 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中異常處理
throw是拋出異常，本方法或類中不進行處理，由調用處進行處理，發生異常方法終止
try{可能發生異常的處理}catch（Exception e）{發生異常後進行的處理}
catch處理完後，程序繼續執行
希望對你有幫助
❹ java異常處理
publicclassTest{
publicstaticvoidmain(String[]args){
Scannerinput=newScanner(System.in);
inta=1;
intb=0;
try{
while(a<=100000){
System.out.printf("輸入整數：");
b=input.nextInt();
a*=b;
System.out.println(a);
if(a>100000){
thrownewException("乘積超出100000");
}
}
}catch(Exceptione){
e.printStackTrace();
}
}
}
❺ JAVA語言如何進行異常處理
Java通過面向對象的方法進行異常處理，把各種不同的異常進行分類，並提供了良好的介面。
在Java中，每個異常都是一個對象，它是Throwable類或其子類的實例。當一個方法出現異常後便拋出一個異常對象，該對象中包含有異常信息，調用這個對象的方法可以捕獲到這個異常並可以對其進行處理。
Java的異常處理是通過5個關鍵詞來實現的：try、catch、throw、throws和finally。一般情況下是用try來執行一段程序，如果系統會拋出（throw）一個異常對象，可以通過它的類型來捕獲（catch）它，或通過總是執行代碼塊（finally）來處理；try用來指定一塊預防所有異常的程序；
catch子句緊跟在try塊後面，用來指定你想要捕獲的異常的類型；
throw語句用來明確地拋出一個異常；
throws用來聲明一個方法可能拋出的各種異常（當然聲明異常時允許無病呻吟）；
finally為確保一段代碼不管發生什麼異常狀況都要被執行。
❻ JAVA語言中，異常處理有哪幾種方式
有兩中方式:1.捕獲異常,自己處理.
2.throw出去,讓別人處理.
舉個例子:
public class A{
try{
可能放生異常的語句...
}catch(Exception e){
e.getMessage();//自己處理
}
}
public class A throws Exception{
可能放生異常的語句...
}//throw出去,讓別人處理
注意這里用的是throws
如果在方法裡面則用throw
舉例:
public class A{
try{
可能放生異常的語句...
}catch(Exception e){
e.getMessage();//自己處理
throw new Exception ("");
}
}
❼ JAVA語言如何進行異常處理
Java通過面向對象的方法進行異常處理，把各種不同的異常進行分類，並提供了良好的介面。在Java中，每個異常都是一個對象，它是Throwable類或其它子類的實例。當一個方法出現異常後便拋出一個異常對象，該對象中包含有異常信息，調用這個對象的方法可以捕獲到這個異常並進行處理。Java的異常處理是通過5個關鍵詞來實現的：try、catch、throw、throws和finally。一般情況下是用try來執行一段程序，如果出現異常，系統會拋出（throws）一個異常，這時候你可以通過它的類型來捕捉（catch）它，或最後（finally）由預設處理器來處理。
用try來指定一塊預防所有異常的程序。緊跟在try程序後面，應包含一個catch子句來指定你想要捕捉的異常的類型。
throw語句用來明確地拋出一個異常。
throws用來標明一個成員函數可能拋出的各種異常。
可以在一個成員函數調用的外面寫一個try語句，在這個成員函數內部寫另一個try語句保護其他代碼。每當遇到一個try語句，異常的框架就放到堆棧上面，直到所有的try語句都完成。
❽ 教您在Java開發過程中如何應對異常處理
早期的編程語言（比如C語言）沒有異常處理，通常是遇到錯誤返回一個特殊的值或設定一個標志，並以此判斷是不是有錯誤產生。隨著系統規模的不斷擴大，這種錯誤處理已經成為創建大型可維護程序的障礙了。
於是在一些語言中出現了異常處理機制，比如在Basic中的異常處理語句「on error goto」，而Java則在C++基礎上建立了新的異常處理機制。
Java通過面向對象的方法進行異常處理，把各種不同的異常進行分類，並提供了良好的介面。這種機制為復雜程序提供了強有力的控制方式。同時這些異常代碼與「常規」代碼分離，增強了程序的可讀性，編寫程序時也顯得更靈活。
Java中的異常類
在Java中，每個異常都是一個對象，它是Throwable類或其它子類的實例。當一個方法出現異常後便拋出一個異常對象，該對象中包含有異常信息，調用這個對象的方法可以捕獲到這個異常並進行處理。
Throwable類有兩個標准子類：java.lang.Error和java.lang.Exception，即錯誤和異常。錯誤：Error類，一般是指虛擬機相關的問題，如系統崩潰、虛擬機出錯誤、動態鏈接失敗等，這一類錯誤無法恢復或不可能捕獲，將導致應用程序中斷。
異常：Exception類，則是指一些可以被捕獲且可能恢復的異常情況，如數組下標越界Array，Index，OutOf，Bounds，Excepton。數字被零除產生異常：ArithmeticException 、輸入/輸出異常：IOException等。
提示：Java編譯器要求Java程序必須捕獲或聲明所有非運行時的異常，如：FileNotFoundException、IOException等。因為，對於這類異常來說，如果程序不進行處理，可能會帶來意想不到的結果。但運行時出現異常可以不做處理，因為這類異常很普遍，全部處理可能對程序的可讀性和運行效率產生影響。
Java異常處理形式，Java的異常處理是通過5個關鍵詞來實現的：try、catch、throw、throws和finally。一般情況下是用try來執行一段程序，如果出現異常，系統會拋出（throws）一個異常，這時候你可以通過它的類型來捕捉（catch）它，或最後（finally）由預設處理器來處理。
下面是Java異常處理程序的基本形式： try //執行時程序塊 catch ExceptionType1e //對ExceptionType1的處理 catch ExceptionType2e //對ExceptionType2的處理 throw e //再拋出這個「異常」 finally try程序塊和catch語句：遇到一個try語句，「異常」的框架就放到堆棧上面，直到所有的try塊內的語句都完成。如果下一級的try語句沒有對某種「異常」進行處理，堆棧就會展開，直到遇到有處理這種「異常」的try語句。 在try程序後面，應包含一個catch子句來指定你想要捕捉的「異常」的類型。提示：捕獲異常的第一步就是用try … 選定你要捕獲異常的范圍，在執行時，括弧內的代碼會產生異常對象並被拋出。然後你就可以用catch塊來處理異常了。 throw語句和throws語句：throw語句用來明確地拋出一個「異常」。首先，你必須得到一個Throwable類或其它子類產生的實例句柄，通過參數傳到catch子句，或者用new語句來創建一個實例。 下面是throw語句的通常形式： throw ThrowableInstance，提示：執行throw語句後，運行流程將立即停止，throw的下一條語句也將暫停執行。這里new運算符用於創建一個Throwable類的實例，在後文的面向對象編程一文中將詳細講解。 throws語句用來標明一個成員函數可能拋出的各種「異常」。對大多數Exception子類來說，Java編譯器會強迫你聲明在一個成員函數中拋出的「異常」的類型。如果「異常」的類型是Error或RuntimeException，或它們的子類，這個規則不起作用。如果你想明確地拋出一個RuntimeException，你必須用throws語句來聲明它的類型。 提示：當然，你可能對上面的說明不是很明白，不過不要緊，編譯運行下面的Java程序（已經為你做了詳細的注釋）你會理解很多! 現在我們用下面的常式來說明問題： class ThrowsDemo //類名，相應的java源文件應該保存成： ThrowsDemo.javastatic void procere throws IllegalAccessException //throws語句 //拋出IllegalAccessException類型的異常System.out.println ″inside procere″ //輸出文本信息，以說明是在執行procere方法時拋出了異常throw new IllegalAccessException ″demo″ //新生成一個Throwable類實例，然後拋出異常 public static void main String args //main 方法開始，程序從此處執行 try //try語句塊開始procere //調用procere方法，該方法將Throw（拋出）異常信息 catch IllegalAccessException e //處理IllegalAccessException類型的異常， catch語句塊System.out.println ″caught ″ + e 編程並執行程序，其過程如下： E \javacode\exception>java ThrowsDemoinside procerecaught java.lang.IllegalAccessException demo提示：如上面的代碼所示，我們用了一個完整的程序來說明在Java程序中如何使用try…catch…throw等語句。Try … 里產生的異常被捕獲了下來，然後在catch塊里進行處理（這里只是輸出異常信息）。 throws IllegalAccessException標明程序將拋出一個IllegalAccessException類型的異常。IllegalAccessExceptione生成一個異常對象，然後用System.out.println輸出異常信息。 finally語句，有時為了確保一段代碼不管發生什麼異常都要被執行，可以使用關鍵詞finally來標出這樣一段代碼。一個成員函數返回到調用它的成員函數，或者通過一個沒捕捉到的異常，或者通過一個明確的return語句，finally子句總是恰好在成員函數返回前執行。 下面我們以一個比較完整的異常處理程序來說明上面所述的各種異常處理語句的使用問題： class ExceptionDemo //異常使用示例，保存為ExceptionDemo.javastatic void procA try System.out.println ″inside procA″ throw new RuntimeException ″demo″ //拋出異常finally System.out.println ″procA's finally″ //注意：不管發生什麼等會執行!!static void procB try System.out.println ″inside procB″ return //返回，實際上是在finally語句執行完後才返回finally System.out.println ″procB's finally″ public static void main String args try procA catch Exception e System.out.println ″catch ″+e procB提示：在上面的完整程序中，finally後的大括弧內的代碼是任何情況下都會執行的。另外，在procB中，return 語句並沒有立即返回，這一點應該特別注意。你可以親自動手，執行上面的程序試試（編譯和執行類似於上例）。 到目前為止，關於Java的流程式控制制已經完全講完了。要真正理解並掌握它們只有經過大量的練習。而好的方法就是修改上面的每一個程序，讓它們實現你想要的功能，並在此基本上理解Java的流程式控制制。 而要寫好Java程序，熟悉使用Java的流程式控制制和異常處理是非常關鍵的。
❾ java異常處理存在的意義是什麼
對於代碼執行過程中，產生的異常。如果不捕獲處理，程序代碼默認會拋給調用層，如果調用層也未對異常做處理，那麼這個異常會一直往外拋出去，有可能直接將這些信息展現給使用的用戶。使用的用戶看到這些信息根本無法理解出現了什麼錯誤，很有可能會誤以為系統崩潰。
在代碼中做異常處理，可以保證程序運行時，如果產生異常，可以將底層的異常信息捕獲到，轉換為用戶可以接受，或者能看懂的信息，比如說：當前處理有錯誤。等等這類用戶可以理解的信息，而不是程序開發的代碼底層信息。這樣使用的用戶可以根據提示重新操作。
Java代碼中，有些類型轉換、資料庫連接、文件讀取等等操作，異常發生時，不會導致系統崩潰，但有必要讓操作用戶按照正常流程來操作，通過異常處理來反饋給操作用戶。
以上，就是我自己在Java開發過程中，自己的理解和總結，如果有誤，還望多多諒解，多多包含。
❿ 簡述Java異常處理的過程
java中對處理異常有兩個方法,一個是拋出異常,另一個是異常處理.
一 拋出異常
拋出異常就是在需要提示錯誤的時候,通過使用throw語句來拋出異常.例如:
int a = 1;
int b = 2;
if (a>b)
{
throw new Exception("a必須比b小");
}
二 異常處理
異常處理就是使用try catch語句對try塊中包圍的語句拋出的異常做處理,具體怎麼處理要看業務需要.例如:
try
{
.....//try塊包圍的是一段需要處理的代碼
}catch (Exception e)
{
e.printStackTrace();//catch塊是對在try塊中捕獲的異常進行處理,這里是列印錯誤的堆棧信息
}
一個try塊可以跟多個catch塊,最後還有個finally塊,用來執行try塊做完之後需要執行的代碼.例如:
try
{
.....
}catch (SQLException se)
{
se.printStackTrace();
}catch (FileNotFoundException fe)
{
fe.printStackTrace();
}catch (Exception e)
{
e.printStackTrace();
}finally
{
....
}