① java語法規定：受檢查異常，比如IO異常，sql異常，必須向上聲明拋出（使用throwrs關鍵字）或者處理掉否...
編譯器當然不知道你的代碼是否一定會拋出異常。但它知道你的代碼里，哪些是會導致異常的。因此，當遇到會拋出異常的代碼，而你有沒有捕獲語句的時候，它就會報錯。目的並不是為了煩你，而是保證你寫的程序在執行的時候不會因為未知的原因而崩潰。
建議你區分一下靜態和動態的概念。
② mysql dbutil怎麼寫
DbUtils類為做一些諸如關閉連接、裝載JDBC驅動程序之類的常規工作提供有用方法的類，它裡面所有的方法都是靜態的。
A：loadDriver(StringdriveClassName): 這一方法裝載並注冊JDBC驅動程序，如果成功就返回TRUE,不需要去捕捉ClassNotFoundException異常。通過返回值判斷驅動程序是否載入成功。
B：close方法：DbUtils類提供了三個重載的關閉方法。這些方法檢查所提供的參數是不是NULL，如果不是的話，它們就關閉連接(Connection)、聲明（Statement）或者結果集（ResultSet）對象。
C：closeQuietly方法: closeQuietly這一方法不僅能在連接、聲明或者結果集為NULL情況下避免關閉，還能隱藏一些在程序中拋出的SQLException。如果你不想捕捉這些異常的話，這對你是非常有用的。在重載closeQuietly方法時，特別有用的一個方法是 closeQuietly(Connection conn,Statement stmt,ResultSet rs)，使用這一方法，你最後的塊就可以只需要調用這一方法即可。
D: commitAndCloseQuietly(Connection conn)方法和commitAndClose (Connection conn)方法：這兩個方法用來提交連接，然後關閉連接，不同的是commitAndCloseQuietly(Connection conn)方法關閉連接時不向上拋出在關閉時發生的一些SQL異常而commitAndClose (Connection conn)方法向上拋出SQL異常。
③ C#執行SQL語句異常拋出，而且還沒有錯誤提示
拋出異常,沒有有錯誤訊息,是因為你在catch中沒有記錄, 如果要有錯誤信息,就修改catch中的語句, catch(Exception ex)
{
MessageBox.Show(ex.Message);
}
④ java throws 向上拋出的概念問題
------------------附註------------------------
向上拋出的意思針對 子類父類,
這裡面涉及到幾個方面,最重要的一點,
(先拋子類的異常,再拋父類的異常.)(FALSE)
如果在該方法寫明catch子句,catch的順序是子類異常,後是父類異常.
若在子類異常中捕獲了,則不用向父類(也就是您講的上一級)拋出,所有的異常都有基類java.lang.Throwable,也可自定義,多用於業務層面.
--------以下轉載自http://blog.163.com/moonlight_yz/blog/static/747367220085583312410/---
什麼時候使用throws？
在基礎方法可能產生的異常使用throws，在應用方法的地方捕獲異常處理。
如果在每層基礎方法處捕獲異常，那麼在應用方法處很可能會忽略掉下層基礎方法處理出的null。所以更好的方式是讓基礎方法throws異常以提醒調用它的應用方法捕獲並處理它。
何時使用throw？
在需要最終處理一些事件的地方，例如：
publicResultSetquery(Stringsql)throwsNullPointerException,SQLException{
try{
conn=pool.getConnection();
pstmt=conn.prepareStatement(sql);
rs=pstmt.executeQuery();
}catch(NullPointerExceptione){
thorwnewNullPointerException();//在此拋出的null異常可以不用在方法後面throws；且此異常出現一定會被捕獲到；
}catch(SQLExceptione){
thrownewSQLException();
}finally{
pool.releaseConnection(conn);
}
returnrs;
}
這里為了finally釋放連接，捕獲了異常，但是並不想在基礎類的地方處理它，所以重新拋出，讓調用它的應用方法可以注意到並判斷處理。
特殊的Exception：NullPointerException。
NullPointerException在被拋出後可以不用throws也可被調用的方法捕獲到。見上例注釋。
***********************jmuok2013-4-700:26***********************************
public class TestException{
public static void main(String[] args){
throw new FatherException();
// throw new ChildException();
// 比較兩者區別.
}
}
class FatherException extends RuntimeException{
public FatherException(){
System.out.println("My name is father exception....");
}
}
class ChildException extends FatherException {
public ChildException() {
System.out.println("My name is child exception....");
}
}
--throw new FatherException();--------result---------
Exception in thread "main" My name is father exception....
com.monical.FatherException
at com.monical.TestException.main(TestException.java:5)
--throw new ChildException();---------result---------
My name is father exception....
My name is child exception....
Exception in thread "main" com.monical.ChildException
at com.monical.TestException.main(TestException.java:6)
⑤ shell腳本中sqlplus怎麼拋出異常
WHENEVER OSERROR
也就是當出現操作系統錯誤或者SQL錯誤的時候該怎麼處理
例子：
sqlplus -s / <<EOF
whenever sqlerror exit SQL.SQLCODE
declare
e exception;
pragma exception_init( e, -1652 );
begin
raise e;
end;
/
EOF是End Of File，既文件的結尾標記，在這里用來標記一段代碼，通常是多行
用"<<"加上一個標記就可以把一大段代碼存入到一個變數中去了，在執行sqlplus時就執行變數中的代碼
這里sqlplus要使用silent模式
spool a.txt
之後做的所有操作都會輸出到a.txt里
spool可以獲取反饋的所有信息並保存到文件
每次spool都會覆蓋原來的文件
然後spool off
那如果只想添加，不想覆蓋
spool append a.txt
…………………………………………………………………………………………………………………………………………windows:
我們先來看WINDOWS環境該怎麼處理 （不顯示sql語句）
echo create table ostab (i int);|sqlplus scott/tiger；
作用就是，直接在cmd里創建了表，然後退出
define _editor=NOTEPAD
windows默認就是notepad,所以可以不用設置
create table t1 ( x int, a int );
insert into t1 values ( 1, null );
insert into t2 values ( 1, 55 );
insert into t2 values ( 1, 100 );
update ( select a, b
from t1, t2
where t1.x = t2.x )
set a = b;
是不是執行錯誤？
那我是不是得修改這個腳本？
其實 我可以通過修改第1行就能解決這個SQL問題
那我有什麼辦法修改第1行？
第一行是不是update (select a,b
我要改成update ( select a, b
那我怎麼樣改這個語句？
因為是修改第一行
所以前面輸入1 update ( select a, b
1表示第一行變成後面語句
這樣第1行就修改完畢
那修改完畢後
然後執行
l或者;
注意： l或者;是顯示所有SQL腳本
4*表示最後一行是第4行*是最後一行
⑥ 方法異常要向上拋出，關鍵字 throws 聲明可能產生的異常 有什麼用是給誰看的編譯器還是人
Java 異常的處理
在 Java 應用程序中，對異常的處理有兩種方式：處理異常和聲明異常。
處理異常：try、catch 和 finally
若要捕獲異常，則必須在代碼中添加異常處理器塊。這種 Java 結構可能包含 3 個部分，
都有 Java 關鍵字。下面的例子中使用了 try-catch-finally 代碼結構。
1 import java.io.*;
2 public class EchoInputTryCatchFinally {
3 public static void main(String args[]){
4 System.out.println("Enter text to echo:");
5 InputStreamReader isr = new InputStreamReader(System.in);
6 BufferedReader inputReader = new BufferedReader(isr);
7 try{
8 String inputLine = inputReader.readLine();
9 System.out.println("Read:" + inputLine);
10 }
11 catch(IOException exc){
12 System.out.println("Exception encountered: " + exc);
13 }
14 finally{
15 System.out.println("End. ");
16 }
17 }
18}
其中：
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 異常處理的分類
Java 異常可分為可檢測異常，非檢測異常和自定義異常。
可檢測異常
可檢測異常經編譯器驗證，對於聲明拋出異常的任何方法，編譯器將強制執行處理或聲明規則，例如：sqlExecption 這個異常就是一個檢測異常。你連接 JDBC 時，不捕捉這個異常，編譯器就通不過，不允許編譯。
非檢測異常
非檢測異常不遵循處理或聲明規則。在產生此類異常時，不一定非要採取任何適當操作，編譯器不會檢查是否已解決了這樣一個異常。例如：一個數組為 3 個長度，當你使用下標為3時，就會產生數組下標越界異常。這個異常 JVM 不會進行檢測，要靠程序員來判斷。有兩個主要類定義非檢測異常：RuntimeException 和 Error。
Error 子類屬於非檢測異常，因為無法預知它們的產生時間。若 Java 應用程序內存不足，則隨時可能出現 OutOfMemoryError；起因一般不是應用程序的特殊調用，而是 JVM 自身的問題。另外，Error 一般表示應用程序無法解決的嚴重問題。
RuntimeException 類也屬於非檢測異常，因為普通 JVM 操作引發的運行時異常隨時可能發生，此類異常一般是由特定操作引發。但這些操作在 Java 應用程序中會頻繁出現。因此，它們不受編譯器檢查與處理或聲明規則的限制。
自定義異常
自定義異常是為了表示應用程序的一些錯誤類型，為代碼可能發生的一個或多個問題提供新含義。可以顯示代碼多個位置之間的錯誤的相似性，也可以區分代碼運行時可能出現的相似問題的一個或者多個錯誤，或給出應用程序中一組錯誤的特定含義。例如，對隊列進行操作時，有可能出現兩種情況：空隊列時試圖刪除一個元素；滿隊列時試圖添加一個元素。則需要自定義兩個異常來處理這兩種情況。
Java 異常處理的原則和忌諱
Java 異常處理的原則
盡可能的處理異常
要盡可能的處理異常，如果條件確實不允許，無法在自己的代碼中完成處理，就考慮聲明異常。如果人為避免在代碼中處理異常，僅作聲明，則是一種錯誤和依賴的實踐。
具體問題具體解決
異常的部分優點在於能為不同類型的問題提供不同的處理操作。有效異常處理的關鍵是識別特定故障場景，並開發解決此場景的特定相應行為。為了充分利用異常處理能力，需要為特定類型的問題構建特定的處理器塊。
記錄可能影響應用程序運行的異常
至少要採取一些永久的方式，記錄下可能影響應用程序操作的異常。理想情況下，當然是在第一時間解決引發異常的基本問題。不過，無論採用哪種處理操作，一般總應記錄下潛在的關鍵問題。別看這個操作很簡單，但它可以幫助您用很少的時間來跟蹤應用程序中復雜問題的起因。
根據情形將異常轉化為業務上下文
若要通知一個應用程序特有的問題，有必要將應用程序轉換為不同形式。若用業務特定狀態表示異常，則代碼更易維護。從某種意義上講，無論何時將異常傳到不同上下文（即另一技術層），都應將異常轉換為對新上下文有意義的形式。
Java 異常處理的忌諱
一般不要忽略異常
在異常處理塊中，一項最危險的舉動是「不加通告」地處理異常。如下例所示：
1 try{
2 Class.forName("business.domain.Customer");
3 }
4 catch (ClassNotFoundException exc){}
經常能夠在代碼塊中看到類似的代碼塊。有人總喜歡在編寫代碼時簡單快速地編寫空處理器塊，並「自我安慰地」宣稱准備在「後期」添加恢復代碼，但這個「後期」變成了「無期」。
這種做法有什麼壞處？如果異常對應用程序的其他部分確實沒有任何負面影響，這未嘗不可。但事實往往並非如此，異常會擾亂應用程序的狀態。此時，這樣的代碼無異於掩耳盜鈴。
這種做法若影響較輕，則應用程序可能出現怪異行為。例如，應用程序設置的一個值不見了， 或 GUI 失效。若問題嚴重，則應用程序可能會出現重大問題，因為異常未記錄原始故障點，難以處理，如重復的 NullPointerExceptions。
如果採取措施，記錄了捕獲的異常，則不可能遇到這個問題。實際上，除非確認異常對代碼其餘部分絕無影響，至少也要作記錄。進一步講，永遠不要忽略問題；否則，風險很大，在後期會引發難以預料的後果。
不要使用覆蓋式異常處理塊
另一個危險的處理是覆蓋式處理器（blanket handler）。該代碼的基本結構如下：
1 try{
2 // …
3 }
4 catch(Exception e){
5 // …
6 }
使用覆蓋式異常處理塊有兩個前提之一：
1. 代碼中只有一類問題。
這可能正確，但即便如此，也不應使用覆蓋式異常處理，捕獲更具體的異常形式有利物弊。
2. 單個恢復操作始終適用。
這幾乎絕對錯誤。幾乎沒有哪個方法能放之四海而皆準，能應對出現的任何問題。
分析下這樣編寫代碼將發生的情況。只要方法不斷拋出預期的異常集，則一切正常。但是，如果拋出了未預料到的異常，則無法看到要採取的操作。當覆蓋式處理器對新異常類執行千篇一律的任務時，只能間接看到異常的處理結果。如果代碼沒有列印或記錄語句，則根本看不到結果。
更糟糕的是，當代碼發生變化時，覆蓋式處理器將繼續作用於所有新異常類型，並以相同方式處理所有類型。
一般不要把特定的異常轉化為更通用的異常
將特定的異常轉換為更通用異常時一種錯誤做法。一般而言，這將取消異常起初拋出時產生的上下文，在將異常傳到系統的其他位置時，將更難處理。見下例：
1 try{
2 // Error-prone code
3 }
4 catch(IOException e){
5 String msg = "If you didn 』 t have a problem before,you do now!";
6 throw new Exception(msg);
7 }
因為沒有原始異常的信息，所以處理器塊無法確定問題的起因，也不知道如何更正問題。
不要處理能夠避免的異常
對於有些異常類型，實際上根本不必處理。通常運行時異常屬於此類范疇。在處理空指針或者數據索引等問題時，不必求助於異常處理。
Java 異常處理的應用實例
在定義銀行類時，若取錢數大於余額時需要做異常處理。
定義一個異常類 insufficientFundsException。取錢（withdrawal）方法中可能產生異常，條件是余額小於取額。
處理異常在調用 withdrawal 的時候，因此 withdrawal 方法要聲明拋出異常，由上一級方法調用。
異常類：
class Exception{
private Bank excepbank; // 銀行對象
private double excepAmount; // 要取的錢
InsufficientFundsException(Bank ba, double dAmount)
{ excepbank=ba;
excepAmount=dAmount;
}
public String excepMessage(){
String str="The balance is"+excepbank.balance
+ "\n"+"The withdrawal was"+excepAmount;
return str;
}
}// 異常類
銀行類：
class Bank{
double balance;// 存款數
Bank(double balance){this.balance=balance;}
public void deposite(double dAmount){
if(dAmount>0.0) balance+=dAmount;
}
public void withdrawal(double dAmount)
throws InsufficientFundsException{
if (balance<dAmount) throw new
InsufficientFundsException(this, dAmount);
balance=balance-dAmount;
}
public void showBalance(){
System.out.println("The balance is "+(int)balance);
}
}
前端調用：
public class ExceptionDemo{
public static void main(String args[]){
try{
Bank ba=new Bank(50);
ba.withdrawal(100);
System.out.println("Withdrawal successful!");
}catch(InsufficientFundsException e) {
System.out.println(e.toString());
System.out.println(e.excepMessage());
}
}
}
回頁首
總結
Java 異常處理是使用 Java 語言進行軟體開發和測試腳本開發中非常重要的一個方面。對異常處理的重視會是您開發出的代碼更健壯，更穩定。本文系統的闡述了 Java 異常處理的原理和方法。能幫助讀者更加清楚的理解 Java 異常處理機制，在開發代碼時更加靈活的使用它。
⑦ 發生sql異常如何處理
大量數據時建議使用存儲過程提高效率同時進行錯誤處理begin try
begin transaction
insert into types values(@typename,@blogman)
insert into bloginfo values(@blogman,@blogtitle,@blogcontent,@@identity,getdate(),0)
commit transaction
return @@identity
end try
begin catch
rollback transaction
return 0
end catch
⑧ 如何在sqlserver 的函數或存儲過程中拋出異常
aiserror 的作用： raiserror 是用於拋出一個錯誤。[ 以下資料來源於sql server 2005的幫助 ]
其語法如下：
RAISERROR ( { msg_id | msg_str | @local_variable }
{ ,severity ,state }
[ ,argument [ ,...n ] ]
)
[ WITH option [ ,...n ] ]
簡要說明一下：
第一個參數：{ msg_id | msg_str | @local_variable }
msg_id：表示可以是一個sys.messages表中定義的消息代號；
使用 sp_addmessage 存儲在 sys.messages 目錄視圖中的用戶定義錯誤消息號。
用戶定義錯誤消息的錯誤號應當大於 50000。
msg_str：表示也可以是一個用戶定義消息，該錯誤消息最長可以有 2047 個字元；
（如果是常量，請使用N'xxxx'，因為是nvarchar的）
當指定 msg_str 時，RAISERROR 將引發一個錯誤號為 5000 的錯誤消息。
@local_variable：表示也可以是按照 msg_str 方式的格式化字元串變數。
第二個參數：severity
用戶定義的與該消息關聯的嚴重級別。（這個很重要）
任何用戶都可以指定 0 到 18 之間的嚴重級別。
[0,10]的閉區間內，不會跳到catch；
如果是[11,19],則跳到catch；
如果[20,無窮)，則直接終止資料庫連接；
第三個參數：state
如果在多個位置引發相同的用戶定義錯誤，
則針對每個位置使用唯一的狀態號有助於找到引發錯誤的代碼段。
介於 1 至 127 之間的任意整數。（state 默認值為1）
當state 值為 0 或大於 127 時會生成錯誤！
第四個參數：argument
用於代替 msg_str 或對應於 msg_id 的消息中的定義的變數的參數。
第五個參數：option
錯誤的自定義選項，可以是下表中的任一值：
LOG ：在錯誤日誌和應用程序日誌中記錄錯誤；
NOWAIT：將消息立即發送給客戶端；
SETERROR：將 @@ERROR 值和 ERROR_NUMBER 值設置為 msg_id 或 50000；
[SQL]代碼示例
--示例1DECLARE @raiseErrorCode nvarchar(50)
SET @raiseErrorCode = CONVERT(nvarchar(50), YOUR UNIQUEIDENTIFIER KEY)
RAISERROR('%s INVALID ID. There is no record in table',16,1, @raiseErrorCode)
--示例2RAISERROR (
N'This is message %s %d.', -- Message text,
10, -- Severity,
1, -- State,
N'number', -- First argument.
5 -- Second argument.
);
-- The message text returned is: This is message number 5.
GO
--示例3RAISERROR (N'<<%*.*s>>', -- Message text.
10, -- Severity,
1, -- State,
7, -- First argument used for width.
3, -- Second argument used for precision.
N'abcde'); -- Third argument supplies the string.
-- The message text returned is: << abc>>.
GO
--示例4RAISERROR (N'<<%7.3s>>', -- Message text.
10, -- Severity,
1, -- State,
N'abcde'); -- First argument supplies the string.
-- The message text returned is: << abc>>.
GO
--示例5
--A. 從 CATCH 塊返回錯誤消息
以下代碼示例顯示如何在 TRY 塊中使用 RAISERROR 使執行跳至關聯的 CATCH 塊中。
它還顯示如何使用 RAISERROR 返回有關調用 CATCH 塊的錯誤的信息。
BEGIN TRY
RAISERROR ('Error raised in TRY block.', -- Message text.
16, -- Severity.
1 -- State.
);
END TRY
BEGIN CATCH
DECLARE @ErrorMessage NVARCHAR(4000);
DECLARE @ErrorSeverity INT;
DECLARE @ErrorState INT;
SELECT
@ErrorMessage = ERROR_MESSAGE(),
@ErrorSeverity = ERROR_SEVERITY(),
@ErrorState = ERROR_STATE();
RAISERROR (@ErrorMessage, -- Message text.
@ErrorSeverity, -- Severity.
@ErrorState -- State.
);
END CATCH;
--示例6
--B. 在 sys.messages 中創建即席消息
以下示例顯示如何引發 sys.messages 目錄視圖中存儲的消息。
該消息通過 sp_addmessage 系統存儲過程，以消息號50005添加到 sys.messages 目錄視圖中。
sp_addmessage @msgnum = 50005,
@severity = 10,
@msgtext = N'<<%7.3s>>';
GO
RAISERROR (50005, -- Message id.
10, -- Severity,
1, -- State,
N'abcde'); -- First argument supplies the string.
-- The message text returned is: << abc>>.
GO
sp_dropmessage @msgnum = 50005;
GO
--示例7
--C. 使用局部變數提供消息文本
以下代碼示例顯示如何使用局部變數為 RAISERROR 語句提供消息文本。sp_addmessage @msgnum = 50005,
@severity = 10,
@msgtext = N'<<%7.3s>>';
GO
RAISERROR (50005, -- Message id.
10, -- Severity,
1, -- State,
N'abcde'); -- First argument supplies the string.
-- The message text returned is: << abc>>.
GO
sp_dropmessage @msgnum = 50005;
GO
⑨ 怎麼將sql中觸發器的自定義錯誤拋出到java類中
、throw關鍵字通常用在方法體中，並且拋出一個異常對象。程序在執行到throw語句時立即停止，它後面的語句都不執行。通過throw拋出異常後，如果想在上一級代碼中來捕獲並處理異常，則需要在拋出異常的方法中使用throws關鍵字在方法聲明中指明要跑出的異常；如果要捕捉throw拋出的異常，則必須使用try—catch語句。舉例如下：
class MyException extends Exception { //創建自定義異常類
String message; //定義String類型變數
public MyException(String ErrorMessagr) { //父類方法
message = ErrorMessagr;
}
public String getMessage(){ //覆蓋getMessage()方法
return message;
}
}
public class Captor { //創建類
static int quotient(int x,int y) throws MyException{//定義方法拋出異常
if(y < 0){ //判斷參數是否小於0
throw new MyException("除數不能是負數");//異常信息
}
return x/y;//返回值
}
public static void main(String args[]){ //主方法
try{ //try語句包含可能發生異常的語句
int result = quotient(3,-1);//調用方法quotient()
}catch (MyException e) { //處理自定義異常
System.out.println(e.getMessage()); //輸出異常信息
}
catch (ArithmeticException e) {
//處理ArithmeticException異常
System.out.println("除數不能為0");//輸出提示信息
}
catch (Exception e) { //處理其他異常
System.out.println("程序發生了其他的異常");
//輸出提示信息
}
}
}
⑩ 程序中凡是可能出現異常的地方必須進行捕獲或拋出對嗎
一、異常的種類
java異常可以分成兩大類：Exception和RuntimeException(雖然RuntimeException是從Exception繼承的)。exception異常代表「無法避免的異常」 如io異常 往往這類異常是由於外部原因造成的，程序本身無法保證他們不發生，所以這類異常必須捕獲。如果在函數內部無法處理這個異常必須再次拋出（在函數後面用throws語句），如果什麼都不做就出現編譯錯誤。
runtimexception是指「可以避免的異常」，如 null引用異常，這類異常都是由程序內部原因造成的，是可以避免的。對於這類異常可以忽略他們，但一旦發生程序就會異常終止。這類異常對debug非常有幫助，當然，如果需要也可以catch。
另外，有些地方即使不會有exception，但是從商業邏輯上是錯誤的、非預期的，也可以拋出user exception。例如，用戶輸入非法，bank account非法透支等等。
二、主要原則
處理意外的一個重要原則，就是要麼處理，要麼接著拋，決不能吃掉（You either handle it, or throw it. You don』t eat it.）這就是說，當你捕獲一個異常之後，必須決定是否立即處理這個異常，或者繼續拋出這個異常（或者另一個自定義異常），以便由調用的客戶端捕獲之。當客戶端捕獲到以後，又會繼續進行類似的判斷。
一般來說，GUI端是要處理異常的，比如JSP捕獲到異常之後，需要先是給用戶一個友好的出錯信息，而不要給出系統的出錯信息。系統的出錯信息一方面不太友好，另一方面提供了太多的系統信息，容易被惡意用戶用來攻擊系統。
換句話說，所有的異常最終必須有一個終極的處理者，這就是GUI。至於中間的環節，比如在伺服器端運行的JavaBean是否要處理捕獲到的異常，還是繼續拋出所捕獲的異常，需要視具體情況處理。
除非你想把異常處理的責任交給調用者，一般不用throws。比如你要讀入一些文件，如果你想通知調用者，讓調用者決定如何處理這個異常，你就把這個異常throws給調用者；如果你知道應該如何處理這個異常，或者你想把異常馬上解決，你可以就地catch她。
這完全取決於你想把異常自己立即處理還是想把處理責任返回給調用者。取決於你的程序的結構和要求。
需要注意的有：
1、如果無法處理某個異常，那就不要捕獲它。
2、如果捕獲了一個異常，請不要胡亂處理它。
3、盡量在靠近異常被拋出的地方捕獲異常。
4、在捕獲異常的地方將它記錄到日誌中，除非您打算將它重新拋出。
5、按照您的異常處理必須多精細來構造您的方法。
6、需要用幾種類型的異常就用幾種，尤其是對於應用程序異常。
三、異常嵌套和捕獲適當的異常
按照Java語言的定義，所謂異常（Exception）指的就是向調用方法（calling method）表示發生非正常情況的習慣方式。下面討論兩種在處理異常時可茲利用的技術：異常嵌套和捕獲適當的異常。
異常嵌套
你在試圖捕獲異常並打算扔出異常時該採取什麼措施呢？同時，你希望原始的異常信息可用嗎？
要回答以上的問題你不妨嘗試一下NestedException類。具體的編程並不難，唯一要做的無非是利用構造器並且重載printStackTrace()以便顯示出正確的數據。
此外，你還應當考慮封裝Throwable而非Exception類來創建更具有重用性的組件。之後，你可以創建NestedRuntimeException變數封裝Throwable但無需對其進行聲明。
捕獲適當的異常
正確地處理異常並不是一項輕松的任務，這是因為異常的處理有時會導致程序出現其他不明行為。不過，以下三條規則可以幫助你避免錯誤處理異常所可能遭遇的風險。
規則 #1: 總是捕獲扔出異常的類型而不要理睬異常的超類。為了遵守通常的代碼習慣，你可以採用Exception類的大寫字母作為變數名，如下所示：
catch(FileNotFoundException fnfe)
以及
catch(SQLException sqle)
規則 # 2: 決不讓catch塊留空。在很多情況下雖然確實編寫了try/catch塊但在代碼的catch部分卻什麼都沒有做。或者，如果採用了日誌API（Logging API），那麼請編寫代碼把異常寫到日誌中。
規則 # 3: 決不扔出Exception基類的實例。開發人員應當總是扔出自己創建的異常類。
扔出異常的API很難處理。在聲明方法扔出java.lang.Exception的情況下，所有的問題都會強加在API用戶的頭上，這樣他們就無法以一種專業的編程方式來處理異常。通過為扔出API聲明Exception類的子類這一舉措，API開發人員就可以減輕用戶的負擔。
以上提到的兩種技術在處理異常時還可能用得更好、更適當。嵌套技術令異常扔到另一異常的內部，而捕獲適當的異常令程序調試大大簡化。