⑴ java語言如何進行異常處理，關鍵字：throws,throw,try,catch,finally分別代表什麼意義
package com.fml.resource;
import javax.swing.Icon;
import javax.swing.JOptionPane;
public class CaiShuZi4JOptionPane {
/**
* @param args
*/
public static void main(String[] args) {
Icon icon = null;
boolean bl = false;
int put = 0;
int c = (int) (((Math.random())*100)+1); //獲取一個1-100的隨機數
System.out.println("你獲取的隨機數是："+c); //列印你的隨機數字
String str1 = (String) JOptionPane.showInputDialog(null,"請輸入你的猜測數字(1-100)： ","猜數字游戲",JOptionPane.PLAIN_MESSAGE,icon,null,"在這輸入"); //第一次輸入你的猜測數字
if(str1==null){
JOptionPane.showMessageDialog(null, "你已經取消了本次游戲"); //如果你點取消那麼本次游戲結束
}else{
bl = num(str1); //判斷是輸入的是不是數字或者是整數
if(true==bl){ //如果是數字的話進入與隨機數比較的程序
System.out.println("你輸入的數字是："+str1); //列印你輸入的數字
put = Integer.valueOf(str1);
for(int i = 4;i > 0;i--){ //i是你可以猜測的次數
if(put==c){
JOptionPane.showMessageDialog(null, "恭喜你猜對了，正確答案是:"+c+"。"); //如果你猜對了就直接結束循環
break;
}else if(put>c){ //如果輸大了就讓你再次從新輸入
str1 = (String) JOptionPane.showInputDialog(null,"你的輸入過大。你還有"+i+"次機會，請重新輸入： ","猜數字游戲",JOptionPane.PLAIN_MESSAGE,icon,null,"在這輸入");
if(str1==null){
JOptionPane.showMessageDialog(null, "你已經取消了本次輸入");
break;
}else{
bl =num(str1);
if(true==bl){
put = Integer.valueOf(str1);
}else{
JOptionPane.showMessageDialog(null, "你的輸入不正確，請重新輸入");
}
}
}else if(put<c){ //如果你輸小了也讓你從新輸入
str1 = (String) JOptionPane.showInputDialog(null,"你的輸入過小。你還有"+i+"次機會，請重新輸入： ","猜數字游戲",JOptionPane.PLAIN_MESSAGE,icon,null,"在這輸入");
if(str1==null){
JOptionPane.showMessageDialog(null, "你已經取消了本次輸入");
break;
}else{
bl =num(str1);
if(true==bl){
put = Integer.valueOf(str1);
}else{
JOptionPane.showMessageDialog(null, "你的輸入不正確，請重新輸入");
}
}
}
}
}else if(bl==false){ //這個 是你第一次如果填寫的不是數字的話也會結束本次游戲
JOptionPane.showMessageDialog(null, "請您下次按要求填寫。本次游戲結束");
}
if(true==bl && c!=put){ //如果你i次都沒猜對，那麼就直接告訴你這個數十什麼
JOptionPane.showMessageDialog(null, "很遺憾你沒能猜對，這個數字是："+c+".");
}
}
}
public static boolean num(String value){ //一個靜態方法，判斷你輸入的是不是數字
try {
Integer.parseInt(value);
return true;
} catch (Exception e) {
return false;
}
}
}
你先看看我的實例，最下面的一個就是捕獲異常和進行處理的方法
在整個JAVA的異常處理中，實際上也是按照面向對象的方式進行處理，處理的步驟如下：
1、一旦產生異常，將會產生一個異常類的實例化對象。
2、在try語句中對這個異常對象進行捕獲。
3、產生的異常對象與catch語句中的各個異常類型進行匹配，如果匹配成功，則執行catch語句中的代碼。
Try{
}catch(…){
} finally{
……
}
這個finally如果沒有中途退出最後是一定會執行到的。
throws是用在主類前面的，是讓他的父類來處理這個異常。不在此類中處理
⑵ 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表示很難恢復的錯誤，如內存越界。一般不期望用戶程序來處理，即使程序員有能力處理這種錯誤，也還是交給系統處理為好。
⑶ java異常 throw和try-catch的關系
throw是把當前方法中出現的異常拋出去，自己不處理，處理異常交給要調用它的方法；try-catch是成對出現的，意思是在try中捕獲的異常馬上交給catch去處理
⑷ JAVA語言如何進行異常處理,關鍵字:throws,throw,try,catch,finally分別代表什麼意
throw 僅用於方法定義後面，指示該方法可能會拋出什麼異常，使用該方法的方法必須處理該異常，或者再次拋出。
throws 用於當程序判斷發生異常時，用該語句拋出異常，或處理異常時再次拋出異常。
//下面三個關鍵字就是處理異常
try {
//這里放可能會發生異常的語句
} catch(Exception e) {
//這里處理異常
} finally {
//這里的語句必然會得到執行，不管異常發省與否，
//用於關閉資料庫，關閉連接等收尾操作（非必要）
}
java異常的一個簡單例子，比如我有一個除法方法
public int divide(int a, int b) {
return a / b;
}
但是這就有一個問題，當b是0時，程序會報錯。
如果引入異常，改成這樣
public int divide(int a, int b) throws Exception {
if (b == 0) {
throw new Exception("b = 0");
}
return a / b;
}
那麼調用端該怎麼用呢
public class ExceptionTest {
public static void main(String[] args) {
ExceptionTest et = new ExceptionTest();
try {
System.out.println(et.divide(12, 0));
} catch (Exception e) {
System.out.println("0不能做被除數");
}
}
public int divide(int a, int b) throws Exception {
if (b == 0) {
throw new Exception("b = 0");
}
return a / b;
}
}
程序可以繼續執行，不會中斷。
⑸ Java異常處理中關鍵字throws,throw,try,catch,finally分別代表什麼意義在try塊中可以拋出異常嗎
throws是用來聲明一個方法可能拋出的所有異常信息
throw則是指拋出的一個具體的異常類型。
通常在一個方法（類）的聲明處通過throws聲明方法（類）可能拋出的異常信息，而在方法（類）內部通過throw聲明一個具體的異常信息。
throws通常不用顯示的捕獲異常，可由系統自動將所有捕獲的異常信息拋給上級方法；
throw則需要用戶自己捕獲相關的異常，而後在對其進行相關包裝，最後再將包裝後的異常信息拋出。
對異常處理方式不同.throws對異常不處理,誰調用誰處理,throws的Exception的取值范圍要大於方法內部異常的最大范圍,而cathch的范圍又要大於throws的Exception的范圍;throw 主動拋出自定義異常類對象. throws拋出的是類,throw拋出的是對象.
在方法定義中表示的是陳述語氣，第三人稱單數，throw 顯然要加s。(throws 一般用作方法定義的子句)
在函數體中要用throw，實際上是祈使句+強調，等價於DO throw ....,do +動詞原形
throw 用於引發異常，可引發預定義異常和自定義異常。
I)異常中「throws」和「throw」的區別:
throw 是個「動詞」，緊接在try語句塊之後。
而throws 是「名詞」 ，用在函數方法名後 function A () throws Exception e {}
throw用在程序中明確表示這里拋出一個異常。throws用在方法聲明的地方，表示這個方法可能會拋出某異常。
throw用來拋出實際的異常, 後面要跟一個異常對象(實例), 是一個實際的語句
throws是用來聲明的, 加在方法聲明的後面, 後面跟一個異常類的名字, 表示一般性動作而不是特指某一個動作.
使用throws是來說明，當前的函數會拋出一個異常。
在一般的情況下，你調用的一些函數會拋出一些異常。但是你又不想在當前的context中去處理它，就可以聲明該函數會拋出該異常，這樣你就不用去try-catch它了。當出現該異常,該函數會拋出此異常，讓上一層的函數去處理。throws也稱異常規范
public static h() throws
{
try
{
a.g();
}
catch(Exception e)
{
throw e;
}
}
因為你沒有對這個異常處理，而是簡單的拋出了。
而單純的聲明
public static h() throws
{
a.g();
}
也會拋出這個異常
II)try catch \throws \throw
throws如果發生了對應的錯誤後，下邊的的確不會被執行；
try catch的理解應該辯證點看：如果catch後沒有再次throw出去，那會繼續執行；要想不執行必須throw處理
throws 拋出異常，解決不了再向上,直道碰到能解決這個異常的處理程序，就好像你的上司讓你執行一項任務，中途你遇到問題不知道如何解決，你把問題返還給你的上司，認為既然是T分配的任務就該知道如何解決這個問題，你的上司無法解決同樣把它送給經理解決，依次向上，直到有人能解決這個問題為止（不想自己另外寫代碼處理異常時非常有用）
try catch 則是考慮到try包含這段代碼可能會遇到這種異常，直接用catch捕獲處理，catch包含的代碼為處理代碼
throws 只是把一個異常拋出去了，如果你的上層代碼有處理方式，就由上層代碼來處理這個異常。
而try/catch對是清楚的知道該操作可能出現什麼異常，同時在catch塊中應該有處理的方法。
而且還有一種方式就是try/catch/finaly的方式。
Throws是把異常返回給調用者，由調用者處理，調用者還是要try/catch，跑不掉的
catch中就一個簡單的SYSTEM.OUT.PRINTLN（…………）；還有，連接資料庫時會連接不上，你也不知道是驅動問題、電腦問題還是網路問題，發給用戶，用戶也看不懂，所以統統throws給catch，提示請與管理員聯系。。。。。。這就簡單多了
throws 寫在方法簽名後，
throw 寫在方法體內，可以寫在if()....
也可以catch住一個exception後立刻又把他throw 出去，什麼處理也不做，還可以catch住後throw new 一個你自己定義的exception ....
throws 就是把異常拋出，但是在以後要不有個catch接受，要不就拋給主函數.就是逐級往上一級拋，直到有一個接受他的
Throws拋出異常交給調用該方法的方法 處理，即：
public class Test{
public static void main(String[] args){
Test2 test2 = new Test2();
try{
System.out.println("invoke the method begin!");
test2.method();
System.out.println("invoke the method end!");
}catch(Exception e){
System.out.println("catch Exception!");
}
}
}
class Test2{
public void method() throws Exception{
System.out.println("method begin!");
int a = 10;
int b = 0;
int c = a/b;
System.out.println("method end!");
}
}
很明顯，答案出來了：
invoke the method begin!
method begin!
catch Exception!
finally語句是任選的，try語句後至少要有一個catch或一個finally,finally語句為異常處理提供一個統一的出口，不論try代碼塊是否發生了異常事件，finally塊中的語句都會被執行
在覆蓋的方法中聲明異常
在子類中，如果要覆蓋父類的一個方法，或父類中的方法聲明了throws異常，則子類的方法也可以拋出異常，但切記子類方法拋出的異常只能是父類方法拋出的異常的同類或子類。
如：
import java.io.*;
class A {
public void methodA()throws IOException{
.....
}
}
class B1 extends A {
public void methodA()throws FileNotFoundException{
....}
}
class B2 extends A {
public void methodA()throws Exception{//Error
....}
}
public void method() throws Exception {
try {
具體程序
} catch(Exception ex) {
}
}
如果具體程序出錯的話，將處理下面程序體中catch的地方,這個時候throws Exception 其實是沒有意義的。
public void method() throws Exception {
try {
具體程序
} catch(FileNotFoundException ex) {
}
}
如果具體程序出錯的話，且是FileNotFoundException 的情況下，將處理下面程序體中catch的地方處理。
這個時候FileNotFoundException 以外的Exception 將通過 throws Exception ，throw到上一層。
throw寫在方法體內, throws寫在方法名的後面
throw關鍵字的格式：throw new ArithmeticException(); 拋出一個異常，這些異常可以使unchecked exception(也就是RuntimeException),也可以是checked execption. throw必須有一個捕獲該異常的try/catch語句
throws關鍵字的格式
private void arrayMethod(int[] arr)
throws ,
ArithmeticException {
// Body
}
throws子句列出了方法可能拋出的異常類型，除了Error和RuntimeException異常,方法中可能拋出的異常必須在throws列表中聲明,否則就會出現編譯錯誤。
例如：假如方法中可能拋出IllegalAccessException(屬於checked execption)則必須在throws列表中聲明。
系統異常是默認拋出的,自己定義的異常要顯示拋出
還有一些是庫方法只throw 沒有處理的,所以表面上你看到沒有throw也catch到異常
⑹ java編程中，throws Exception{ }和try{……}catch(){……}
區別一：throw 是語句拋出一個異常；throws 是方法拋出一個異常；
throw語法：throw <異常對象>
在方法聲明中，添加throws子句表示該方法將拋出異常。如果一個方法會有異常，但你並不想處理這個異常，就在方法名後面用throws,這樣這個異常就會拋出，誰調用了這個方法誰就要處理這個異常，或者繼續拋出.
throws語法：[<修飾符>]<返回值類型><方法名>（[<參數列表>]）[throws<異常類>]
其中：異常類可以聲明多個，用逗號分割。
區別二：throw要麼和try-catch-finally語句配套使用，要麼與throws配套使用。但throws可以單獨使用，然後再由處理異常的方法捕獲。
聯系一：try .... catch 就是用catch 捕獲 try 中的異常，並處理；catch是捕獲異常。也就是說某一個操作有可能會拋出什麼異常。throw 就是不處理異常，直接拋出異常
調用一個會throws exception的方法（在方法定義的時候可以用throws實現）時，需要把這個方法放在try里，然後用catch破獲這個exception，做相應的處理。
throw new exception（）是拋出一個exception，由別的method來破獲它。
也就是說try....catch是為破獲別人的exception用的，而throw是自己拋出exception讓別人去破獲的。
public void input() throws Exception
{ }
public void outputException()
{
try {
input();
}
catch(Exception e)
{
System.out.println("Exception");
}
}
簡單的說，如果一個方法中用了throws，那麼這個方法會向上拋出一個異常，那麼在調用這個方法的時候必須把這個調用放在try...catch塊里處理這個異常。
對於異常有兩種處理方法
1、要麼聲明異常，也就是在方法名後面加上throws exceptionname,..., 方法本身只是拋出異常，由函數調用者來捕獲異常。 若產生異常，異常會沿著調用棧下移，一直找到與之匹配的處理方法，若到達調用棧底仍未找到，程序終止。
2、要麼捕獲異常。通過try catch方法，catch子句中放置處理異常的語句。
聯系二：對於會覺得會有異常拋出的程序塊，用try{}包住，然後用catch來抓住這個異常，在catch中對異常做處理， 在try中如果有異常的話，程序會轉到catch而不會中斷，通常這兩個是配合使用的,如果你不想因為程序有錯，而拋出一大堆異常的話，你就把該程序try起來，try和catch只能獲取程序運行時引發的異常，而throw語句可以引發明確的異常，程序到了throw語句這後就立即停止，不會執行後面的程序,
大家也許在編程的過程中，會意識到這里出錯，但不知道會拋出什麼異常，也是一件頭疼的事，現將這部分總結如下：
算術異常類：ArithmeticExecption
空指針異常類：NullPointerException
類型強制轉換異常：ClassCastException
數組負下標異常：NegativeArrayException
數組下標越界異常：
違背安全原則異常：SecturityException
文件已結束異常：EOFException
文件未找到異常：FileNotFoundException
字元串轉換為數字異常：NumberFormatException
操作資料庫異常：SQLException
輸入輸出異常：IOException
方法未找到異常：NoSuchMethodException
⑺ JAVA語言如何進行異常處理，關鍵字throws,throw,try,catch,finally分別代表什麼意義在try塊中拋出異常嗎
throws用在方法聲明中,表明當前方法在運行時會有異常拋出,需要在調用該方法的時候注意控制異常
throw用在方法體內，手動製造一個異常，中斷代碼的繼續執行
try-catch-finally是一起使用的
當某段代碼在運行期間可能會發生異常而終止執行時，使用。
結構為
try
{
//可能發生異常的代碼
}
catch （異常類型 ）
{
//異常發生時的處理方式
}
finally
{
//其他必須執行的語句
}
當try語句塊中的代碼在執行時發生異常,就會被catch捕獲，進入catch語句塊進行處理，如果沒有發生異常就繼續執行
finally語句塊中的代碼是一些必須執行的語句,這里的代碼無論try中是否發生異常都會被執行
⑻ 水能詳細講解一下java 中的異常處理 try catch throw
沒怎麼用過throw。用過try和catch。
1.throw，等你程序比如檢測到一個非法的值，則可以寫代碼，專門throw，拋出這個異常（後期會有人捕獲並處理的）
2.
catch，我是和try一起用的。
即：
try{
做你要做的事情，
尤其是可能會出錯的某些事情
比如通過網路訪問某個地址
則可能出現超時等情況，此時最好就是把相關代碼放到此try中
}
catch()
{
然後在catch中捕獲，處理對應的異常
比如是超時的異常，就彈出個對話框，告訴用戶超時了，之類的
}
3.總之，把可能，容易出錯的代碼，放到try中，
然後在catch中寫相關的錯誤的處理的代碼。即可。
感興趣的話，用google搜：
crifanlib.cs
裡面有我寫的各種函數，其中有用到try和catch。