javathrow和throws

⑴ java語言中throw和throws的區別是什麼

一、

throw關鍵字用於在代碼中拋出一個異常，如：

throw new Exception("異常一");

下面是一個例子：

⑵ java中拋出異常throw和throws有什麼區別

1.throws 用於拋出方法層次的異常， 並且直接由些方法調用異常處理類來處理該異常， 所以它常用在方法的後面。比如 public static void main(String[] args) throws SQLException 2.throw 用於方法塊裡面的代碼，比throws的層次要低，比如try...catch ....語句塊，表示它拋出異常， 但它不會處理它， 而是由方法塊的throws Exception來調用異常處理類來處理。

⑶ 在Java中，throw與throws有什麼區別他們各自用在什麼地方

throw
用來拋出異常throws
用來標識可能拋出的異常
public
class
Person
{
public
void
display()
throws
Exception{
System.out.println("hello
everyone");
}
}
public
class
Test
{
public
static
void
main(String[]args){
Person
person
=
new
Person();
//在Person中的display方法拋出了異常,在調用display方法是需要捕捉
try
{
person.display();
}
catch
(Exception
e)
{
e.printStackTrace();
}
}
}
//在調用方法時,如果有用到用throws標識了異常的方法,程序最終被運行之前必須要被捕捉

⑷ Java中throw和throws的區別

都是關鍵字

throw用於代碼當中拋出異常；throws用於方法名結尾定義方法拋出的異常類型。

例如

inta=1;
thrownewException();
system.out.println("a");

在throw這行控制台會報Exception異常，如果你new的是NullPointException就會報空指針異常，你拋什麼他報什麼。下面的輸出不會執行，程序終止。

如果使用了異常處理，例如

inta=1;
try{
a=2;
thrownewException();
a=3;
}catch(Exceptione){
systemt.out.println(a);
a=4;
}
system.out.println(a);

這樣在a賦2後手動拋異常，被catch捕獲，然後輸出a、a賦4，最終結果是輸出2、4。

而throws用途：

publicvoidmethod()throwsException{...}

這個方法被調用後，如果這個方法里出了錯，這個錯誤就會被拋給引用它的那個方法。在控制台就會看到一層一層拋上去的引用棧。

⑸ 在java中，throw與throws有什麼區別

1、throw是在代碼塊內的，即在捕獲方法內的異常並拋出時用的；

2、throws是針對方法的，即將方法的異常信息拋出去

3、可以理解為throw是主動（在方法內容里我們是主動捕獲並throw的），而throws是被動（在方法上是沒有捕獲異常進行處理，直接throws的）

4、例子：

publicvoidstr2int(Stringstr)throwsException{//這里將得到的異常向外拋出
try{
System.out.println(Integer.parseInt(str));

}catch(NumberFormatExceptione){
//TODO這里可以做一些處理，處理完成後將異常報出，讓外層可以得到異常信息
thrownewException("格式化異常");
}
}

⑹ java中，throws與throw有什麼不同

在類和方法後面用throws，直接拋出異常就要用到throw。
參考的是英語的語法，英語里就是第三人稱後面要+s

⑺ Java中throws和throw的區別講解

1.throw：（針對對象的做法）
拋出一個異常，可以是系統定義的，也可以是自己定義的。下面舉兩個例子：
拋出Java中的一個系統異常：
public class One {
public void yichang(){
NumberFormatException e = new NumberFormatException();
throw e;
}
public static void main(String[] args){
One test = new One();
try{
test.yichang();
}catch(NumberFormatException e){
System.out.println(e.getMessage());
}
}
}
拋出一個自定義的異常：

public class People {
public static int check(String strage) throws MyException{
int age = Integer.parseInt(strage);
if(age < 0){
throw new MyException("年齡不能為負數！");
}
return age;
}
public static void main(String[] args){
try{
int myage = check("-101");
System.out.println(myage);
}catch(NumberFormatException e){
System.out.println("數據格式錯誤");
System.out.println("原因:" + e.getMessage());
}catch(MyException e){
System.out.println("數據邏輯錯誤");
System.out.println("原因：" + e.getMessage());
}
}
}
public class MyException extends Exception{
private static final long serialVersionUID = 1L;
private String name;
public MyException(String name){
this.name = name;
}
public String getMessage(){
return this.name;
}
}
2.throws：（針對一個方法拋出的異常）
拋出一個異常，可以是系統定義的，也可以是自己定義的。
拋出java中的一個系統異常：
public class One {
public void yichang() throws NumberFormatException{
int a = Integer.parseInt("10L");
}
public static void main(String[] args){
One test = new One();
try{
test.yichang();
}catch(NumberFormatException e){
System.out.println(e.getMessage());
}
}
}
拋出一個自定義異常：
public class People {
public static int check(String strage) throws MyException{
int age = Integer.parseInt(strage);
if(age < 0){
throw new MyException("年齡不能為負數！");
}
return age;
}
public static void main(String[] args){
try{
int myage = check("-101");
System.out.println(myage);
}catch(NumberFormatException e){
System.out.println("數據格式錯誤");
System.out.println("原因:" + e.getMessage());
}catch(MyException e){
System.out.println("數據邏輯錯誤");
System.out.println("原因：" + e.getMessage());
}
}
}
public class MyException extends Exception{
private static final long serialVersionUID = 1L;
private String name;
public MyException(String name){
this.name = name;
}
public String getMessage(){
return this.name;
}
}
3.那麼下面我要說究竟什麼時候用哪種：

如果是系統異常的話可以什麼都不用做，也可以針對方法拋出一個異常，因為系統異常是可以被系統自動捕獲的，所以這個異常究竟是要在方法內部解決還是交給上
層函數去解決其實效果是一樣的。但是我查了很多資料，即使會拋出異常能被系統所捕獲的話還是建議針對方法寫一個throws，因為這樣在完成一個大型任務
的時候可以讓別的程序員知道這里會出現什麼異常。
如果是自己定義的異常，則必須要用throws拋出該方法可能拋出的異常，否則編譯會報錯。

⑻ Java中throw和throws有什麼區別

當然，你需要明白異常在Java中式以一個對象來看待。
並且所有系統定義的編譯和運行異常都可以由系統自動拋出，稱為標准異常，但是一般情況下Java 強烈地要求應用程序進行完整的異常處理，給用戶友好的提示，或者修正後使程序繼續執行。
直接進入正題哈：
1.用戶程序自定義的異常和應用程序特定的異常,必須藉助於 throws 和 throw 語句來定義拋出異常。

1.1 throw是語句拋出一個異常。
語法：throw (異常對象);
throw e;

1.2 throws是方法可能拋出異常的聲明。(用在聲明方法時，表示該方法可能要拋出異常)
語法：[(修飾符)](返回值類型)(方法名)([參數列表])[throws(異常類)]{......}
public void doA(int a) throws Exception1,Exception3{......}

舉例：

throws E1,E2,E3隻是告訴程序這個方法可能會拋出這些異常，方法的調用者可能要處理這些異常，而這些異常E1，E2，E3可能是該函數體產生的。
throw則是明確了這個地方要拋出這個異常。

如： void doA(int a) throws IOException,{
try{
......

}catch(Exception1 e){
throw e;
}catch(Exception2 e){
System.out.println("出錯了！");
}
if(a!=b)
throw new Exception3("自定義異常");
}

代碼塊中可能會產生3個異常，(Exception1,Exception2,Exception3)。
如果產生Exception1異常，則捕獲之後再拋出，由該方法的調用者去處理。
如
果產生Exception2異常，則該方法自己處理了（即System.out.println("出錯了！");）。所以該方法就不會再向外拋出
Exception2異常了，void doA() throws Exception1,Exception3
裡面的Exception2也就不用寫了。
而Exception3異常是該方法的某段邏輯出錯，程序員自己做了處理，在該段邏輯錯誤的情況下拋出異常Exception3，則該方法的調用者也要處理此異常。

throw語句用在方法體內，表示拋出異常，由方法體內的語句處理。
throws語句用在方法聲明後面，表示再拋出異常，由該方法的調用者來處理。

throws主要是聲明這個方法會拋出這種類型的異常，使它的調用者知道要捕獲這個異常。
throw是具體向外拋異常的動作，所以它是拋出一個異常實例。

throws說明你有那個可能，傾向。
throw的話，那就是你把那個傾向變成真實的了。

同時：
1、throws出現在方法函數頭；而throw出現在函數體。
2、throws表示出現異常的一種可能性，並不一定會發生這些異常；throw則是拋出了異常，執行throw則一定拋出了某種異常。
3、兩者都是消極處理異常的方式（這里的消極並不是說這種方式不好），只是拋出或者可能拋出異常，但是不會由函數去處理異常，真正的處理異常由函數的上層調用處理。

⑼ 8.java中throw和throws的區別

throw是語句拋出一個異常。
語法：throw (異常對象);
throw e;

throws是方法可能拋出異常的聲明。(用在聲明方法時，表示該方法可能要拋出異常)
語法：[(修飾符)](返回值類型)(方法名)([參數列表])[throws(異常類)]{......}
public void doA(int a) throws Exception1,Exception3{......}

⑽ JAVA的throw和throws怎麼用!

throw是語句拋出一個異常；語法：throw（異常對象）；

(10)javathrow和throws擴展閱讀：

throw與throws的區別

1、throw用在方法體內，上面代碼顯示了，是直接在main方法體內

throws用在方法聲明後面，表示再拋出異常，由該方法的調用者來處理。這個看上面的代碼就理解了。

2、throw是具體向外拋異常的，拋出的是一個異常實例。

throws聲明了是哪種類型的異常，使它的調用者可以捕獲這個異常。

3、throw，如果執行了，那麼一定是拋出了某種異常了，安生throws表示可能出現，但不一定。

4、同時出現的時候，throws出現在函數頭、throw出現在函數體，兩種不會由函數去處理，真正的處理由函數的上層調用處理。