java基礎第十篇之異常

1.1接口概念
類:具備相同屬性和功能的事物集合

接口是功能的集合，一樣可看作是一種數據類型，是比抽象類更爲抽象的」類」。

接口只描述所應該具有的方法，並無具體實現，具體的實現由接口的實現類(至關於接口的子類)來完成。這樣將功能的定義與實現分離，優化了程序設計。
請記住：一切事物均有功能，即一切事物均有接口。

與定義類的class不一樣，接口定義時須要使用interface關鍵字。
定義接口所在的仍爲.java文件，雖然聲明時使用的爲interface關鍵字的編譯後仍然會產生.class文件。這點可讓咱們將接口看作是一種只包含了功能聲明的特殊類。

使用interface代替了原來的class，其餘步驟與定義類相同：
 接口中的方法均爲公共訪問的抽象方法
 接口中沒法定義普通的成員變量

類與接口的關係爲實現關係，即類實現接口。實現的動做相似繼承，只是關鍵字不一樣，實現使用implements。
其餘類(實現類)實現接口後，就至關於聲明：」我應該具有這個接口中的功能」。實現類仍然須要重寫方法以實現具體的功能。

在類實現接口後，該類就會將接口中的抽象方法繼承過來，此時該類須要重寫該抽象方法，完成具體的邏輯。
 接口中定義功能，當須要具備該功能時，可讓類實現該接口，只聲明瞭應該具有該方法，是功能的聲明。
 在具體實現類中重寫方法，實現功能，是方法的具體實現。
因而，經過以上兩個動做將功能的聲明與實現便分開了。(此時請從新思考：類是現實事物的描述，接口是功能的集合。)

1.4接口中成員的特色
一、接口中能夠定義變量，可是變量必須有固定的修飾符修飾，public static final 因此接口中的變量也稱之爲常量，其值不能改變。後面咱們會講解static與final關鍵字
二、接口中能夠定義方法，方法也有固定的修飾符，public abstract
三、接口不能夠建立對象。
四、子類必須覆蓋掉接口中全部的抽象方法後，子類才能夠實例化。不然子類是一個抽象類。

1.5接口特色
 接口能夠繼承接口
如同類繼承類後便擁有了父類的成員，可使用父類的非私有成員。A接口繼承B接口後，A接口便擁有了A、B兩個接口中全部的抽象方法。
 Java支持一個類同時實現多個接口，或一個接口同時繼承多個接口。
 類能夠在繼承一個類的同時，實現多個接口。
接口與父類的功能能夠重複，均表明要具有某種功能，並不衝突。

三、經過上面的例子總結接口和抽象類的區別：
相同點:
 都位於繼承的頂端,用於被其餘類實現或繼承;
 都不能直接實例化對象;
 都包含抽象方法,其子類都必須覆寫這些抽象方法;
區別:
 抽象類爲部分方法提供實現,避免子類重複實現這些方法,提升代碼重用性;
 接口只能包含抽象方法;
 一個類只能繼承一個直接父類(多是抽象類),卻能夠實現多個接口;(接口彌補了Java的單繼承)

 抽象類爲繼承體系中的共性內容,接口爲繼承體系外的擴展功能

 

兩者的選用:
 優先選用接口,儘可能少用抽象類;
 須要定義子類的行爲,又要爲子類提供共性功能時才選用抽象類;

包的特色:
A:能夠有多層
B:不一樣包下的文件名能夠

C:包的聲明必須是第一行代碼

不一樣包之間的互相訪問
1.使用類的全名

2.使用關鍵字import 將類導入

注意:*表明得是通配符,表明導入了這個包全部的類,並無導入子包下的類

相同包下的類能夠直接訪問,不須要作其餘的操做

類的全名:包名.類名

權限修飾符:
public 當前類,相同包下不一樣的類,不一樣包下的類
default 當前類,相同包下不一樣的類,
private 當前類
protected 當前類,相同包下不一樣的類

default : 當前包下使用
protected:讓子類對象使用

在Java中提供了四種訪問權限，使用不一樣的訪問權限時，被修飾的內容會有不一樣的訪問權限，如下表來講明不一樣權限的訪問能力：
public protected default private
同一類中 √ √ √ √
同一包中(子類與無關類) √ √ √
不一樣包的子類 √ √
不一樣包中的無關類 √
概括一下：在平常開發過程當中，編寫的類、方法、成員變量的訪問
A:要想僅能在本類中訪問使用private修飾
B:要想本包中的類均可以訪問除了private修飾符,其它均可以
C:要想本包中的類與其餘包中的子類能夠訪問使用protected修飾
D:要想全部包中的全部類均可以訪問使用public修飾。
注意：若是類用public修飾，則類名必須與文件名相同。一個文件中只能有一個public修飾的類。

成員內部類:
* 在類的成員位置,和成員變量以及成員方法所在的位置是同樣的.
* 在內部類當中,科院直接訪問外部類的成員,包括私有成員

成員內部類的修飾符:
* 可使用權限修飾符修飾成員內部類,可是若是使用私有來修飾,則沒法再其餘類中被訪問.
* 咱們可使用static 修飾成員內部類,不用在建立外部類的對象了
*
* 咱們可使用abstract,final修飾成員內部類

局部內部類:
* 在方法內,出了方法以後就沒法使用

局部內部類:
* 在方法內,出了方法以後就沒法使用
*
* 匿名內部類:
* 能夠把匿名內部類當作是一個沒有名字的局部內部類
* 定義在方法當中
* 必須在定義匿名內部類的時候建立他的對象
* 格式:
* new 類/接口() {
* 若是是建立了繼承這個類的子類對象,咱們能夠從新父類的方法
* 若是是建立了實現這個接口的子類對象,咱們必需要實現該接口的全部方法
* }
*
* 原理:而是建立了繼承這個類的子類對象或者是建立了實現這個接口的子類對象
*
* 匿名內部類的應用場景:
* 做爲參數進行傳遞

Object : equals , toString

Object類中的equals:
* 默認比較的是兩個對象的地址,是當前對象和參數傳入的對象
* 可是咱們能夠重寫equals方法,讓比較按照咱們的想法比較
* 好比java中String也是重寫了equals,比較了字符串的內容,而不是地址
*
* Object類中的toString方法:
* 這個方法 能夠方法一個字符串,這個字符串用來表示當前對象
* 默認返回值:包名.類名@地址值
* 實際上 syso(對象名) 等價於 syso(對象名.toString())
* 可是咱們也能夠重寫toString 打印出咱們要的信息 而不是一個地址值
*
* 總結:實際開發中定義一個類 咱們一般
* 1.封裝
* 2.構造
* 3.重寫equals
* 4.toString();//方便查看對象的信息


* 程序的異常:(程序中出現的問題)
* 根類Throwable
* |- Error(錯誤類)是程序很嚴重的問題,若是出現了 改代碼
* 人:肝癌,腦殼被砍了
* |- Exception(編譯時異常類)也是程序出現問題,本身能夠處理的小問題
* 人:感冒,發燒,牙疼..
* |- RuntimeExcetpion(運行時異常)
*
* java中異常類的常見操做
*
* 1.先要有異常,通常來講 java的異常java本身常見對象,咱們本身定義一個異常,咱們本身常見對象
*
* 2.拋出異常(無論了)
*
* 3.捕獲異常(本身處理)
*
* 拋出異常的關鍵字:throw, 拋出的動做,是真正的把異常對象拋出去


* 1.throw:拋出異常動做
*
* 2.throws:一種聲明,throws是給方法作聲明的,表示這個方法可能拋出異常,要求方法的調用者去處理
*
* 3.處理異常的方法:
* 3.1再聲明拋出
* 3.2捕獲方式:
* try{
* 可能出現異常的代碼;
* }catch(Exception e){
* //若是上面的代碼,真的出現了異常 那麼就會被抓住
* //就是把異常對象賦值給了 e
* //本身處理
* }finally{
* //最終必需要執行的代碼
* //通常放釋放資源的代碼
* }
* 捕獲異常還有其餘的方式:
* try{
* }finally{
* }
* try{
* }catch(Exception e){
* }
* 關於catch抓住異常 也有其餘寫法
* 處理：
* 1多個異常分別處理 咱們基本不用
* 2多個異常一次捕獲屢次處理
* 3多個異常一次捕獲一次處理 ***********
*


* 異常的分類:
* 1.編譯時異常: Exception以及它的子類(RuntimeException)
* 2.運行時異常: RuntimeExcetion以及它的子類
*
* 咱們如何區分哪一個是編譯異常 哪一個是運行異常?

編譯期異常拋出，未來調用者必須處理。
運行期異常拋出，未來調用能夠不用處理。

javac出來的異常就是編譯時異常，就是說把源代碼編譯成字節碼（class）文件時報的異常，通常若是用Eclispe,你敲完代碼保存的時候就是編譯的時候。

Java出來的異常就是運行時異常

/自定義異常固定的套路
//1.必須繼承Exception或者RuntimeException
//2.寫兩個構造,一個空參,一個帶有異常信息的String類型參數
//throw new NoSuchAgeException("年齡不合法的異常");

可以辨別程序中異常(Exception)和錯誤(Error)的區別
* 錯誤:是程序出現很是嚴重的問題,必須修改源代碼
* 異常:是程序出現的小問題,給出問題的代碼加上處理方式
*
* 說出異常的分類:
* 根類:Throwable
* |-Error
* |-Exception:編譯時異常
* |-RuntimeException:運行時異常
* 說出虛擬機處理異常的方式
* 終斷方式:
* 1.打印異常信息
* 2.終止JVM運行
* 列舉出常見的四個運行期異常
* NullPointerException
* ArrayIndexOutofBoundsException
* StringIndexOutofBoundsException
* ClassCastException;//類型轉型異常,貓不能轉成狗
*
* 可以使用try...catch關鍵字處理異常
* 標準方式: try{..可能出異常的代碼..}catch(異常類型 變量名){...}finally{..釋放資源的代碼..}
* 奇葩的方式:
* try{....}finally{...}
* try{....}catch(異常類型 變量名){..}
* catch捕獲異常的方式:
* 1.一個異常一個捕獲 一次處理 (多個try 多個catch)
* 2.多個異常一次捕獲 屢次處理(一個try,多個catch);
* 3.多個異常一個捕獲,一次處理(一個try 一個catch)
* 可以使用throws關鍵字處理異常
* throw:就是真正拋出一個異常
* throws:給方法用的,給方法作聲明,聲明這個方法可能拋出異常,要求調用者去處理
* 可以自定義異常類
* 固定套路:
* 1.定義一個Exception結尾異常類,繼承Exception或者RuntimeException
* 2.兩個構造:無參數,帶有異常信息的String類型參數
* 可以處理自定義異常類
* 若是自定義異常繼承RuntimeException 編譯時不會出錯,咱們也不須要處理
* 若是自定義異常繼承Exception,這時候咱們須要處理(throws聲明拋出,try..catch)
* 可以理解Object的equals方法
* equals方式定義在Object類中,默認實現判斷當前對象和形式參數對象,是否地址相同
* public boolean equals(Object obj){
*
* return (this==obj);
* }
* 若是咱們想改變equals判斷規則,那麼咱們本身重寫equals
*
* 能偶理解Object的toString方法
* toString方法定義在Object類中,默認實現打印下面的格式: 包名.類名@地址值
* 咱們也能夠重寫toString打印出來咱們要的對象信息
*
* syso(對象名)====>syso(對象名.toString())
*

當定義一個Animal類時,咱們發現咱們並無寫成員方法,可是能調用,這是由於它繼承了Object類.
Object類是Java語言中的根類，即全部類的父類。它中描述的全部方法子類均可以使用。全部類在
建立對象的時候，最終找的父類就是Object。

equals方法，用於比較兩個對象是否相同，它其實就是使用兩個對象的內存地址在比較。Object類
中的equals方法內部使用的就是==比較運算符。

注意：在複寫Object中的equals方法時，必定要注意public boolean equals(Object obj)的參數是Object類型
，在調用對象的屬性時，必定要進行類型轉換，在轉換以前必須進行類型判斷。
友情提示:須要重寫的時候能夠利用eclipse提供的快捷鍵直接生成 alt+shift + s + h

1.toString方法返回該對象的字符串表示，其實該字符串內容就是對象的類型+@+內存地址值。
2.在咱們直接使用輸出語句輸出對象名的時候,其實經過該對象調用了其toString()方法.
可是toString返回值的地址 對咱們來講沒有實際價值的
3.因爲toString方法返回的結果是內存地址，而在開發中，常常須要按照對象的屬性獲得相應的
字符串表現形式，所以也須要重寫它。alt+shift + s + s

根類Throwable(異常):
Error(錯誤類):程序很嚴重的問題,沒法處理的異常,若是出現了,改代碼.
Exception(編譯時異常類):若是出現了問題,本身處理.
RuntimeExcetpion(運行時異常):

java中異常類的常見操做:

1.先要有異常,通常來講java的異常java本身常見對象,咱們本身定義一個異常,咱們本身常見對象

2.拋出異常(無論了)

3.捕獲異常(本身處理)

對於頂級類(外部類)來講，只有兩種修飾符：public和默認(default)。由於外部類的上一單元是包，
因此外部類只有兩個做用域：同包，任何位置。所以，只須要兩種控制權限
：包控制權限和公開訪問權限，也就對應兩種控制修飾符：public和默認(default)。

既然你問的類使用了private修飾符，說明是個內部類。內部類的上一級是外部類，那麼對應的有四
種訪問控制修飾符：本類(private)，同包(default)，父子類(protected)，任何位置(public)。
種訪問控制修飾符：本類(private)，同包(default)，父子類(protected)，任何位置(public)。
當一個內部類使用了private修飾後，只能在該類的外部類內部使用。

Object類中的equals: * 默認比較的是兩個對象的地址,是當前對象和參數傳入的對象 * 可是咱們能夠重寫equals方法,讓比較按照咱們的想法比較 * 好比java中String也是重寫了equals,比較了字符串的內容,而不是地址 * * Object類中的toString方法: * 這個方法 能夠方法一個字符串,這個字符串用來表示當前對象 * 默認返回值:包名.類名@地址值 * 實際上 syso(對象名) 等價於 syso(對象名.toString()) * 可是咱們也能夠重寫toString 打印出咱們要的信息 而不是一個地址值 * * 總結:實際開發中定義一個類 咱們一般 * 1.封裝 * 2.構造 * 3.重寫equals * 4.toString();//方便查看對象的信息 程序的異常:(程序中出現的問題) * 根類Throwable * |- Error(錯誤類)是程序很嚴重的問題,若是出現了 改代碼 * 人:肝癌,腦殼被砍了 * |- Exception(編譯時異常類)也是程序出現問題,本身能夠處理的小問題 * 人:感冒,發燒,牙疼.. * |- RuntimeExcetpion(運行時異常) * * java中異常類的常見操做 * * 1.先要有異常,通常來講 java的異常java本身常見對象,咱們本身定義一個異常,咱們本身常見對象 * * 2.拋出異常(無論了) * * 3.捕獲異常(本身處理) * * 拋出異常的關鍵字:throw, 拋出的動做,是真正的把異常對象拋出去 1.throw:拋出異常動做 * * 2.throws:一種聲明,throws是給方法作聲明的,表示這個方法可能拋出異常,要求方法的調用者去處理 * * 3.處理異常的方法: * 3.1再聲明拋出 * 3.2捕獲方式: * try{ * 可能出現異常的代碼; * }catch(Exception e){ * //若是上面的代碼,真的出現了異常 那麼就會被抓住 * //就是把異常對象賦值給了 e * //本身處理 * }finally{ * //最終必需要執行的代碼 * //通常放釋放資源的代碼 * } * 捕獲異常還有其餘的方式: * try{ * }finally{ * } * try{ * }catch(Exception e){ * } * 關於catch抓住異常 也有其餘寫法 * 處理： * 1多個異常分別處理 咱們基本不用 * 2多個異常一次捕獲屢次處理 * 3多個異常一次捕獲一次處理 *********** * 異常的分類: * 1.編譯時異常: Exception以及它的子類(RuntimeException) * 2.運行時異常: RuntimeExcetion以及它的子類 * * 咱們如何區分哪一個是編譯異常 哪一個是運行異常 //自定義異常固定的套路 //1.必須繼承Exception或者RuntimeException //2.寫兩個構造,一個空參,一個帶有異常信息的String類型參數 //throw new NoSuchAgeException("年齡不合法的異常"); public class TestDemo { public static void main(String[] args) { //一個try 多個catch try{ System.out.println("try"); int[] arr = {1,2,3}; arr[10] = 10;//數組下標越界 System.out.println(10/0);//數學異常 String s = "abc"; char ch = s.charAt(10);//字符串下標越界 }catch(ArithmeticException ae){ System.out.println("數學異常"); }catch(ArrayIndexOutOfBoundsException aioe){ System.out.println("數組越界"); }catch(StringIndexOutOfBoundsException sioe){ System.out.println("字符串下標越界"); }finally { } }}