Version:0.9 StartHTML:-1 EndHTML:-1 StartFragment:00000099 EndFragment:00021127java
#異常概述，try-catch處理方式，以及異常聲明throws 方式
/*
異常：就是程序在運行時出現不正常狀況。
異常由來：問題也是現實生活中一個具體的事物，也能夠經過java的類的形式進行描述。並封裝成對象。
其實就是java對不正常狀況進行描述後的對象體現。
對於問題的劃分：兩種：一種是嚴重的問題，一種非嚴重的問題。
對於嚴重的，java經過Error類進行描述。
對於Error通常不編寫針對性的代碼對其進行處理。
對與非嚴重的，java經過Exception類進行描述。
對於Exception可使用針對性的處理方式進行處理。
不管Error或者Exception都具備一些共性內容。
好比：不正常狀況的信息，引起緣由等。
Throwable
|--Error
|--Exception數據庫
2,異常的處理
java 提供了特有的語句進行處理。
try
{
須要被檢測的代碼；
}
catch(異常類 變量)
{
處理異常的代碼；(處理方式)
}
finally
{
必定會執行的語句；
}安全
3，對捕獲到的異常對象進行常見方法操做。
String getMessage()：獲取異常信息。
在函數上聲明異常。
便於提升安全性，讓調用出進行處理。不處理編譯失敗。
*/jvm
class Demo
{
int div(int a,int b)throws Exception//在功能上經過throws的關鍵字聲明瞭該功能有可能會出現問題。
{
return a/b;
}
}函數
class ExceptionDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(4,1);
System.out.println("x="+x);
}
catch (Exception e)//Exception e = new ArithmeticException();
{
System.out.println("除零啦");
System.out.println(e.getMessage());// / by zero;
System.out.println(e.toString());// 異常名稱 ： 異常信息。
e.printStackTrace();//異常名稱，異常信息，異常出現的位置。
//其實jvm默認的異常處理機制，就是在調用printStackTrace方法。
//打印異常的堆棧的跟蹤信息。
}
System.out.println("over");
}
}this
#對多異常的處理。
/*1，聲明異常時，建議聲明更爲具體的異常。這樣處理的能夠更具體。
2，對方聲明幾個異常，就對應有幾個catch塊。不要定義多餘的catch塊。
若是多個catch塊中的異常出現繼承關係，父類異常catch塊放在最下面。
創建在進行catch處理時，catch中必定要定義具體處理方式。
不要簡單定義一句 e.printStackTrace(),
也不要簡單的就書寫一條輸出語句。
*/
class Demo
{
int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException//在功能上經過throws的關鍵字聲明瞭該功能有可能會出現問題。
{
int[] arr = new int[a];
System.out.println(arr[4]);
return a/b;
}
}code
class ExceptionDemo2
{
public static void main(String[] args) //throws Exception
{
Demo d = new Demo();
try
{
int x = d.div(5,0);
System.out.println("x="+x);
}
catch(Exception e)
{
System.out.println("hahah:"+e.toString());
}
catch (ArithmeticException e)
{
System.out.println(e.toString());
System.out.println("被零除了!!");
}
catch (ArrayIndexOutOfBoundsException e)
{
System.out.println(e.toString());
System.out.println("角標越界啦！！");
}
System.out.println("over");
}
}對象
#自定義異常
/*
由於項目中會出現特有的問題，
而這些問題並未被java所描述並封裝對象。
因此對於這些特有的問題能夠按照java的對問題封裝的思想。
將特有的問題。進行自定義的異常封裝。blog
自定義異常。
需求：在本程序中，對於除數是-1，也視爲是錯誤的是沒法進行運算的。
那麼就須要對這個問題進行自定義的描述。繼承
當在函數內部出現了throw拋出異常對象，那麼就必需要給對應的處理動做。
要麼在內部try catch處理。
要麼在函數上聲明讓調用者處理。
通常狀況在，函數內出現異常，函數上須要聲明。
發現打印的結果中只有異常的名稱，卻沒有異常的信息。
由於自定義的異常並未定義信息。
如何定義異常信息呢？
由於父類中已經把異常信息的操做都完成了。
因此子類只要在構造時，將異常信息傳遞給父類經過super語句。
那麼就能夠直接經過getMessage方法獲取自定義的異常信息。
自定義異常：
必須是自定義類繼承Exception。
繼承Exception緣由：
異常體系有一個特色：由於異常類和異常對象都被拋出。
他們都具有可拋性。這個可拋性是Throwable這個體系中獨有特色。
只有這個體系中的類和對象才能夠被throws和throw操做。
throws和throw的區別
throws使用在函數上。
throw使用在函數內。
throws後面跟的異常類。能夠跟多個。用逗號隔開。
throw後跟的是異常對象。
*/
class FuShuException extends Exception //getMessage();
{
private int value;
FuShuException()
{
super();
}
FuShuException(String msg,int value)
{
super(msg);
this.value = value;
}
public int getValue()
{
return value;
}
}
class Demo
{
int div(int a,int b)throws FuShuException
{
if(b<0)
throw new FuShuException("出現了除數是負數的狀況------ / by fushu",b);//手動經過throw關鍵字拋出一個自定義異常對象。
return a/b;
}
}
class ExceptionDemo3
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(4,-9);
System.out.println("x="+x);
}
catch (FuShuException e)
{
System.out.println(e.toString());
//System.out.println("除數出現負數了");
System.out.println("錯誤的負數是："+e.getValue());
}
System.out.println("over");
}
}
/*
class Throwable
{
private String message;
Throwable(String message)
{
this.message = message;
}
public String getMessage()
{
return message;
}
}
class Exception extends Throwable
{
Exception(String message)
{
super(message);
}
}
class Person
{
String name;
Person(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
}
class Student extends Person
{
Student (String name)
{
super(name);
}
}
new Sttdent("lisi").getName();
*/
#RuntimeException
/*
Exceptoin中有一個特殊的子類異常RuntimeException 運行時異常。
若是在函數內容拋出該異常，函數上能夠不用聲明，編譯同樣經過。
若是在函數上聲明瞭該異常。調用者能夠不用進行處理。編譯同樣經過；
之因此不用在函數聲明，是由於不須要讓調用者處理。
當該異常發生，但願程序中止。由於在運行時，出現了沒法繼續運算的狀況，但願中止程序後，
對代碼進行修正。
自定義異常時：若是該異常的發生，沒法在繼續進行運算，
就讓自定義異常繼承RuntimeException。
對於異常分兩種：
1，編譯時被檢測的異常。
2，編譯時不被檢測的異常(運行時異常。RuntimeException以及其子類)
*/
class FuShuException extends RuntimeException
{
FuShuException(String msg)
{
super(msg);
}
}
class Demo
{
int div(int a,int b)throws Exception//throws ArithmeticException
{
if(b<0)
throw new Exception("出現了除數爲負數了");
if(b==0)
throw new ArithmeticException("被零除啦");
return a/b;
}
}
class ExceptionDemo4
{
public static void main(String[] args)
{
Demo d = new Demo();
int x = d.div(4,-9);
System.out.println("x="+x);
System.out.println("over");
}
}
/*
class Person
{
public void checkName(String name)
{
//if(name.equals("lisi"))//NullPointerException
if("lisi".equals(name))//if(name!=null && name.equals("lisi"))
System.out.println("YES");
else
System.out.println("no");
}
}
main()
{
Person p = new Person();
p.checkName(null);
}
*/
#異常——Finnaly
/*
finally代碼塊：定義必定執行的代碼。
一般用於關閉資源。
*/
class FuShuException extends Exception
{
FuShuException(String msg)
{
super(msg);
}
}
class Demo
{
int div(int a,int b)throws FuShuException
{
if(b<0)
throw new FuShuException("除數爲負數");
return a/b;
}
}
class ExceptionDemo5
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(4,-1);
System.out.println("x="+x);
}
catch (FuShuException e)
{
System.out.println(e.toString());
return;
//System.exit(0);//系統，退出。jvm結束。
}
finally
{
System.out.println("finally");//finally中存放的是必定會被執行的代碼。
}
System.out.println("over");
}
}
class NoException extends Exception
{
}
public void method()throws NoException{
鏈接數據庫;
數據操做;//throw new SQLException();
關閉數據庫;//該動做，不管數據操做是否成功，必定要關閉資源。
try
{
鏈接數據庫;
數據操做;//throw new SQLException();
}
catch (SQLException e)
{
會對數據庫進行異常處理;
throw new NoException();
}
finally
{
關閉數據庫;
}
}
#異常——覆蓋（子父之間類）時，異常的特色。
/*
異常在子父類覆蓋中的體現；
1，子類在覆蓋父類時，若是父類的方法拋出異常，那麼子類的覆蓋方法，只能拋出父類的異常或者該異常的子類。
2，若是父類方法拋出多個異常，那麼子類在覆蓋該方法時，只能拋出父類異常的子集。（其餘新的異常，自能內部處理）
3，若是父類或者接口的方法中沒有異常拋出，那麼子類在覆蓋方法時，也不能夠拋出異常。
若是子類方法發生了異常。就必需要進行try處理。絕對不能拋。
*/
class AException extends Exception
{
}
class BException extends AException
{
}
class CException extends Exception
{
}
/*
Exception
|--AException
|--BException
|--CException
*/
class Fu
{
void show()throws AException
{
}
}
class Test
{
void function(Fu f)
{
try
{
f.show();
}
catch (AException e)
{
}
}
}
class Zi extends Fu
{
void show()throws CException
{
}
}
class
{
public static void main(String[] args)
{
Test t = new Test();
t.function(new Zi());
}
}
#異常知識的總結：
是什麼？是對問題的描述。將問題進行對象的封裝。
------------
異常體系：
Throwable
|--Error
|--Exception
|--RuntimeException
異常體系的特色：異常體系中的全部類以及創建的對象都具有可拋性。
也就是說能夠被throw和throws關鍵字所操做。
只有異常體系具有這個特色。
--------------
throw和throws的用法：
throw定義在函數內，用於拋出異常對象。
throws定義在函數上，用於拋出異常類，能夠拋出多個用逗號隔開。
當函數內容有throw拋出異常對象，並未進行try處理。必需要在函數上聲明，都在編譯失敗。
注意，RuntimeException除外。也就說，函數內若是拋出的RuntimeExcpetion異常，函數上能夠不用聲明。
--------------
若是函數聲明瞭異常，調用者須要進行處理。處理方法能夠throws能夠try。
異常有兩種：
編譯時被檢測異常
該異常在編譯時，若是沒有處理(沒有拋也沒有try)，編譯失敗。
該異常被標識，表明這能夠被處理。
運行時異常(編譯時不檢測)
在編譯時，不須要處理，編譯器不檢查。
該異常的發生，建議不處理，讓程序中止。須要對代碼進行修正。
--------------
異常處理語句：
try
{
須要被檢測的代碼；
}
catch ()
{
處理異常的代碼；
}
finally
{
必定會執行的代碼；
}
有三個結合格式：
1. try
{
}
catch ()
{
}
2. try
{
}
finally
{
}
3. try
{
}
catch ()
{
}
finally
{
}
注意：
1，finally中定義的一般是 關閉資源代碼。由於資源必須釋放。
2，finally只有一種狀況不會執行。當執行到System.exit(0);fianlly不會執行。
--------------
自定義異常：
定義類繼承Exception或者RuntimeException
1,爲了讓該自定義類具有可拋性。
2，讓該類具有操做異常的共性方法。
當要定義自定義異常的信息時，可使用父類已經定義好的功能。
異常異常信息傳遞給父類的構造函數。
class MyException extends Exception
{
MyException(String message)
{
super(message);
}
}
自定義異常：按照java的面向對象思想，將程序中出現的特有問題進行封裝。
--------------
異常的好處：
1，將問題進行封裝。
2，將正常流程代碼和問題處理代碼相分離，方便於閱讀。
異常的處理原則：
1，處理方式有兩種：try 或者 throws。
2，調用到拋出異常的功能時，拋出幾個，就處理幾個。
一個try對應多個catch。
3，多個catch，父類的catch放到最下面。
4，catch內，須要定義針對性的處理方式。不要簡單的定義printStackTrace，輸出語句。
也不要不寫。
當捕獲到的異常，本功能處理不了時，能夠繼續在catch中拋出。
try
{
throw new AException();
}
catch (AException e)
{
throw e;
}
若是該異常處理不了，但並不屬於該功能出現的異常。
能夠將異常轉換後，在拋出和該功能相關的異常。
或者異常能夠處理，當須要將異常產生的和本功能相關的問題提供出去，
當調用者知道。並處理。也能夠將捕獲異常處理後，轉換新的異常。
try
{
throw new AException();
}
catch (AException e)
{
// 對AException處理。
throw new BException();
}
好比，匯款的例子。
異常的注意事項：
在子父類覆蓋時：
1，子類拋出的異常必須是父類的異常的子類或者子集。
2，若是父類或者接口沒有異常拋出時，子類覆蓋出現異常，只能try不能拋。
參閱
ExceptionTest.java 老師用電腦上課
ExceptionTest1.java 圖形面積。
class
{
public static void main(String[] args)
{
int x = 0;
try
{
x = 4;
}
catch ()
{
}
finally
{
System.out.println("x="+x);
}
}
}
class
{
public static void main(String[] args)
{
int x = 0;
try
{
x = 4;
}
catch ()
{
}
finally
{
System.out.println("x="+x);
}
}
}