JAVA 學習筆記（3）_面向對象（多態，Object，內部類，異常，包）

【多態】

多態：能夠理解爲事物存在的多種體現形態。

人：男人，女人

動物：貓，狗。

貓 x = new 貓();

動物 x = new 貓();

1，多態的體現

                                        父類的引用指向了本身的子類對象。

                                        父類的引用也能夠接收本身的子類對象。

2，多態的前提

                                        必須是類與類之間有關係。要麼繼承，要麼實現。

                                        一般還有一個前提：存在覆蓋。

3，多態的好處

                                        多態的出現大大的提升程序的擴展性。.

 

4，多態的弊端：

                                        提升了擴展性，可是隻能使用父類的引用訪問父類中的成員。

 

5，多態的應用

 

【多態---轉型】

Animal a = new cat（）；//類型提高。 向上轉型。 （動物有吃方法——貓有吃和抓老鼠方法）

cat c = (cat) a ;    //調用貓的特有方法,向下轉型

注意：                              Animal a = new Animal() ;

                                          Cat c = (Cat) a ; //!

千萬不要出現這樣的操做，就是將父類對象轉成子類類型。

咱們能轉換的是父類應用指向了本身的子類對象時，該應用能夠被提高，也能夠被強制轉換。

多態自始至終都是子類對象在作着變化。

【 instanceof 】

instanceof : （用於判斷對象的類型） if（對象 intanceof 類型(類類型 接口類型)  ）

if(a instanceof cat)  判斷a是否屬cat類型

 

【特色】

在多態中成員函數（非靜態）的特色：

在編譯時期：參閱引用型變量所屬的類中是否有調用的方法。若是有，編譯經過，若是沒有

編譯失敗。

在運行時期：參閱對象所屬的類中是否有調用的方法。

__簡單總結就是：成員函數（非靜態）在多態調用時，編譯看左邊，運行看右邊。

（Fu p = new Zi( ) ; ）

 

在多態中，成員變量的特色：不管編譯和運行，都參考左邊(引用型變量所屬的類)。//面試

 

在多態中，靜態成員函數的特色：不管編譯和運行，都參考作左邊。//面試

 

 

【示例】

/*

需    求：體現接口與多態的特色

例    子：（電腦運行基於主板）

程序描述：主板上能夠定義PCI接口（規則），後期想要拓展聲卡或網卡等功能就能夠經過 實

現（implements）接口來鏈接主板

特    點：提升了擴展性，同時下降了聲卡等與主板的耦合性。

後期若是要擴展其餘卡，只需加上符合PCI規則的子類即可

public void usePCI(PCI c)  //PCI c = new NetCard() // 體現了多態特色

*/

 

【 Object類 】

Object:是全部對象最高級父類（最根類），傳說中的上帝。

該類中定義的確定是全部對象都具有的功能。

 

Object類中已經提供了對對象是否相同的比較方法。

若是自定義類中也有比較相同的功能，沒有必要從新定義。

只要沿襲父類中的功能，創建本身特有比較內容便可。即——>覆蓋。

 

 

【】

java中Object提供的一些功能函數（equals、toString等。。。）

方法 : equals（Object bo） //判斷對象之間是否相等,比較的是指向對象的地址.。

方法：toString（）  //返回對象的哈希值  

 

**代碼例子**

class Demo

{

       private int num ;

       Demo (int num )

       {

              this.num = num;

       }

       public boolean equals(Object bo)

       {

              if(!(bo instanceof Demo))       //判斷bo是否爲Demo類

              return false;

              Demo bb =(Demo) bo;

              return this.num==bb.num;     //將傳近來的數據與類內的變量比較是否相等，相等返

回ture 不相等返回false

       }

}

class Person

{

 

}

class ObjectDemo        //主函數

{

       public static void main (String[] args )

       {

              Demo bo = new Demo(4);

              Demo bo2 = new Demo(4);

              Person p = new Person();

              System.out.println(bo.equals(p)); //會經過Demo複寫的equals方法裏的if判斷掉

             

              System.out.println(bo.toString());//返回bo對象的字符串表示  顯示（Demo@12801c5）

              System.out.println(bo.hashCode());     //返回對象的哈希值 顯示爲（19399109）

              System.out.println(Integer.toHexString(bo.hashCode()));// 將哈希值轉爲十六進制

 顯示爲（12801c5）

       }

}

 

 

【*內部類*】

 

含義：將一個類定義在另外一個類的裏面，對裏面的那個類就稱爲內部類(內置類、嵌套類)

訪問特色：A：內部類能夠直接訪問外部類的成員，包括私有成員；

（之因此能夠直接訪問外部類中的成員，是由於內部類中持有了一個外部類的：引用格式( 外部類名. this.)

          B：而外部類訪問內部類中的成員必需要創建內部類的對象

 

 

1、訪問格式：

1,當內部類定義在外部類的成員位置上，並且非私有，能夠在外部其餘類中。

能夠直接創建內部類對象。

格式

       外部類名.內部類名  變量名 = 外部類對象.內部類對象;

       Outer.Inner in = new Outer().new Inner();

（*___面試小題：直接訪問內部類的成員—>Wai . Nei bo = new Wai ( ) . new Nei ( ) ;___）

 

2、當內部類在成員位置上，就能夠被成員修飾符所修飾。

       好比，private：將內部類在外部類中進行封裝。

                  static:內部類就具有static的特性。（當內部類被static修飾後，只能直接訪問外

部類中的static成員,出現了訪問侷限。）

             

a: 在外部其餘類中，如何直接訪問static內部類的非靜態成員呢？

              new Outer.Inner().function() ;

 

b: 在外部其餘類中，如何直接訪問static內部類的靜態成員呢？

              Outer.Inner.function();

 

注意：當內部類中定義了靜態成員，該內部類必須是static的。

          當外部類中的靜態方法訪問內部類時，內部類也必須是static的。

 

【】何時使用？

當描述事物時，事物的內部還有事物，該事物用內部類來描述。

由於內部事務在使用外部事物的內容。

 

【】

       Demo.NeiBu bo = new Demo. NeiBu(); 

注意：內部類（NeiBu）定義成了靜態，因此用這個格式：new Demo.NeiBu() 編譯才經過，

      用Demo.NeiBu bo = new Demo() . new NeiBu() ; 編譯將不經過！

 

 

【局部內部類】

內部類可定義在類的中的 方法內 或 循環內 ——局部內部類

 

內部類定義在局部時：

1，不能夠被成員修飾符修飾

2，能夠直接訪問外部類中的成員，由於還持有外部類中的引用。

       可是不能夠訪問它所在的局部中的變量。只能訪問被final修飾的局部變量。

 

【匿名內部類】——爲了簡化書寫，覆蓋方法

 

匿名內部類:

1，匿名內部類其實就是內部類的簡寫格式。

2，定義匿名內部類的前提：內部類必須是繼承一個類或者實現接口。

 

1，  匿名內部類的格式：  new 父類或者接口 ( ) {定義子類的內容} ；—建的是子類對象

 

4，其實匿名內部類就必定是一個匿名子類對象。並且這個對象有點胖。能夠理解爲帶內容的對象。

2，匿名內部類中定義的方法最好不要超過3個。

【】

new Object () {

 public void function() {}   

} . function() ;         //這是合法的，Object是全部類的父類，這裏建立了Object匿名子類，並調用該子類中的方法

 

|************************************************************|

【異常】

人體疾病（Throwables）：A不可治癒（Error）:       //人體的比喻

                    B可治癒（Exception）： 1、2、3、4……

 

1、——異    常：就是程序在運行時出現不正常狀況。

異常由來：問題也是現實生活中一個具體的事物，也能夠經過java的類的形式進行描述。並封裝成對象。

                     其實就是java對不正常狀況進行描述後的對象體現。

對於問題的劃分：兩種：一種是嚴重的問題，一種非嚴重的問題。

 

對於嚴重的，java經過Error類進行描述。

       對於Error通常不編寫針對性的代碼對其進行處理。

 

對與非嚴重的，java經過Exception類進行描述。

       對於Exception可使用針對性的處理方式進行處理。

 

2、——異常處理：

java 提供了特有的語句進行處理。

try

{

       須要被檢測的代碼；

}

catch(異常類 變量)

{

       處理異常的代碼；//(處理方式)

}

finally

{

       必定會執行的語句；

}

 

****************

第一個格式：

try

{

}

catch ()

{

}

 

第二個格式：

try

{    

}

catch ()

{

}

finally

{

}

第三個格式：

try

{    

}

finally

{

}

//記住一點：catch是用於處理異常。若是沒有catch就表明異常沒有被處理過，若是該異常是檢測時異常。那麼必須聲明。

*************

3、——對捕獲到的異常對象進行常見（方法）：

String  getMessage ( ) ：獲取 「異常信息」。 //（注意是否帶返回值？）

String  toString ( )    ：獲取 「異常名稱 ： 異常信息」

void  printStackTrace () ：獲取」異常名稱，異常信息，異常出現的位置」

 

其實jvm默認的異常處理機制，就是在調用printStackTrace方法//打印異常的堆棧的跟蹤信息.;

 

4——異常聲明：【throws】     「 拋 」

  // throws : 「拋」的意思，定義的類可能有異常拋給後面的程序員處理

 

class Demo 

{

int div(int a,int b) throws Exception//經過throws的關鍵字聲明該功能有可能會出現問題。

{

       return a/b;

}

}          

//若是後面的程序員解決不了此異常，能夠再拋給JVM處理，經過在main行後再次作異常聲明，（  如：public static void main­(String[] args) throws Exception {}   ）

 

【多異常】

int div(int a,int b)throws 1Exception，2Exception

對多異常的處理：

1，聲明異常時，建議聲明更爲具體的異常。這樣處理的能夠更具體。

2，對方聲明幾個異常，就對應有幾個catch塊。不要定義多餘的catch塊。

若是多個catch塊中的異常出現繼承關係，父類異常catch塊放在最下面。

     ArithmeticException：算數異常； ArrayIndexOutOfBoundsException：角標越界異常

   （ArithmeticException，ArrayIndexOutOfBoundsException兩者是Exception的子類）

 

（創建在進行catch處理時，catch中必定要定義具體處理方式。不要簡單定義一句 e.printStackTrace(), 也不要簡單的就書寫一條輸出語句。）

 

 

【自定義異常】  ——需繼承下

由於項目中會出現特有的問題，

而這些問題並未被java所描述並封裝對象。

因此對於這些特有的問題能夠按照java的對問題封裝的思想。

將特有的問題。進行自定義的異常封裝。

 

1、需求：在本程序中，對於除數是-1，也視爲是錯誤的是沒法進行運算的。

那麼就須要對這個問題進行自定義的異常描述。

 

2、當在函數內部出現了throw拋出異常對象，那麼就必需要給對應的處理動做。

要麼在內部try catch處理。

要麼在函數上聲明讓調用者處理。（再次聲明「拋出」）

 

通常狀況在，函數內出現異常，函數上須要異常聲明。

 

【】

區別：throws 與 throw

throws : 使用在函數上；後面跟的是異常類、能夠跟多個、用逗號隔開。

throw ：使用在函數內；後面跟的是異常對象。

 

【 RuntimeException 】 ——特殊的Exception子類異常

子父類關係：（Exception>>RuntimeException>>ArithmeticException）

特色：RuntimeException下的全部子類都不用異常聲明

RuntimeException： 運行時異常。

若是在函數內容拋出該異常，函數上能夠不用聲明，編譯同樣經過。

若是在函數上聲明瞭該異常。調用者能夠不用進行處理（拋或try catch）。編譯同樣經過；

之因此不用在函數聲明，是由於不須要讓調用者處理。

當該異常發生，但願程序中止。由於在運行時，出現了沒法繼續運算的狀況，但願中止程序後，程序員對代碼進行修正。

class Div

{

       public static int div (int a, int b )

       {

              if (b==0)

              throw new ArithmeticException("被零出啦！！！");  //特色在此，函數上能夠不用異常聲明

              int x = a/b;

              return x;

       }

}

class RuntimeException

{

       public static void main (String[] args )

       {

              int x = Div.div(4,0);

              System.out.println(x);

       }

}

【】

自定義異常時：若是該異常的發生，沒法在繼續進行運算，就讓自定義異常繼承RuntimeException。

 

【】

對於異常分兩種：1，編譯時被檢測的異常。

2，編譯時不被檢測的異常 (運行時異常：RuntimeException以及其子類)

（若是程序出現異常時不能處理就繼承RuntimeException，如能處理要麼拋要麼 try）

 

【 finally 】 

       finally代碼塊：定義必定執行的代碼。 （一般用於關閉資源）關閉數據庫操做

代碼示例：

       數據庫的操做：（鏈接、數據操做、關閉數據庫。）//該動做，不管數據操做是否成功，必定要關閉資源。

public void method( ) throws NoException

{

       try

       {

              鏈接數據庫;

              數據操做;  //throw new SQLException(); 若是數據庫操做異常

       }

       catch (SQLException e)

       {

              會對數據庫進行異常處理;

              throw new NoException() ; //處理完告訴調用者，如提示調用失敗

       }

       finally

       {

              關閉數據庫;  

       }

}

 

 

【】

注意：

1，finally中定義的一般是 關閉資源代碼。由於資源必須釋放。

2，finally只有一種狀況不會執行。當執行到System.exit(0);—系統裏面有靜態exit退出方法

 

【】異常在 子父類 覆蓋中的體現：

|--A異常

   |--B異常

|--C異常

 

1，子類在覆蓋父類時，若是父類的方法拋出異常，那麼子類的覆蓋方法，只能拋出父類的異常或者該異常的子類。

2，若是父類方法拋出多個異常，那麼子類在覆蓋該方法時，只能拋出父類異常的子集。

3，若是父類或者接口的方法中沒有異常拋出，那麼子類在覆蓋方法時，也不能夠拋出異常。

       若是子類方法發生了異常。就必需要進行try處理。絕對不能拋。

class AException extends Exception  //A異常

{}

class BException extends Aexception  //B異常，A的子類異常

{}

class CException        //C異常        

{}

class Fu

{

       void show ( ) throws AException

       {}

}

class Zi extends Fu

{

       void show( ) throws BException //或者拋 AException ,就是不能拋CException；

或者子類什麼都不拋

       {}

}

 

 

 

|************************************************************|

【 包 】____ package

 

「Hello package」代碼：
package pack ; （// 包名所有小寫，定義包代碼寫在最前！）

class packageDemo   //首行建包也能夠一個包下創建N個子包：package n1.n2.n3.n4.n5…；

{

       public static void main (String[] args )

       {

              System.out.println("Hello package!!");

       }

}

 

DOS命令：

D:\javacode>javac -d . packageDemo.java

（點’表明當前地址（D：\javacode）下生成個pack包 幷包裏編譯源文件packageDemo.java）

D:\javacode>javac –d  F:\ package packageDemo.java

（表明在指定目錄F:\ package下生成pack包 並完成編譯）

D:\javacode>set classpath= F:\ package

（由於class文件已不在當前目錄，因此要在DOS設classpath路徑）

D:\javacode>java pack.packageDemo

（classpath路徑後，直接編譯pack包裏的packageDemo.class文件：pack’點’packageDemo）

編譯結果：Hello package!!

 

【】

DOS報錯：

***********

 

PackageDemo.java:8: 找不到符號

符號： 類 DemoA

位置： 類 pack.PackageDemo

                DemoA d = new DemoA();   

                ^

錯誤緣由：類名寫錯。------> 由於類名的全名是：包名.類名

（packA.DemoA bo = new packA.DemoA();）

***********

 

PackageDemo.java:8: 軟件包 packa 不存在

                packa.DemoA d = new packa.DemoA();

                     ^

錯誤緣由：被訪問packa包不在當前目錄下

須要設置classpath，告訴jvm去哪裏找指定的packa包0。

 

 

***********

PackageDemo.java:8: packa.DemoA 在 packa 中不是公共的；沒法從外部軟件包中對其進

行訪問

                packa.DemoA d = new packa.DemoA();

                     ^

錯誤緣由：有了包，範圍變大，一個包中的類要被訪問，必需要有足夠大的權限。

因此被訪問的類要被public修飾。

 

***********

 

PackageDemo.java:9: show() 在 packa.DemoA 中不是公共的；沒法從外部軟件包中對其進

行訪問

                d.show();

                 ^

錯誤緣由：類公有後，被訪問的成員也要公有才能夠被訪問。

 

***********

 

【總結】：

1，包—包之間進行訪問，被訪問的包中的類以及類中的成員，須要public修飾。

2，包的子類包還能夠直接訪問父類中被protected權限修飾的成員。

3，包與包之間可使用的權限只有兩種，public  protected。

 

 

              public   protected     default     private

同一個類中     ok       ok           ok         ok

同一個包中     ok       ok           ok

子類           ok       ok            

不一樣包中       ok

 

 

【 import 導入】

當文件包層次多時，新建對象比較麻煩，

如：pack1.pack2.pack3.pack4.DemoC bo = new pack1.pack2.pack3.pack4.DemoC ( );

可用導入：

import  pack1.pack2.pack3.pack4.DemoC ;   （寫在代碼最前）

  導入後調用對象時就能夠不用寫那麼複雜了： DemoC bo = new DemoC( );

 

  若是一包下有多個class文件在一程序中都將被程序調用，能夠用「*」表明全部class文件

如：import  pack1.pack2.pack3.pack4.* ;

 

【】

注意：定義包名不要重複，可使用url定義，url是唯一的。（用網站域名）

如：www.itcast.cn  

定義包：package cn.itcast.demo； 、 package cn.itcast.test.demo;

 

 

【 jar 包】———— java的壓縮包

優勢：1、方便項目的攜帶；

      2、方便與使用，只要在classpath設置jar路徑便可；

      3、數據庫驅動，SSH框架等都是以jar包體現的。

JDK工具：jar.exe

------------------------

jar命令:

    -c  建立新的歸檔文件

    -t  列出歸檔目錄

    -x  從檔案中提取指定的 (或全部) 文件

    -u  更新現有的歸檔文件

    -v  在標準輸出中生成詳細輸出

    -f  指定歸檔文件名

    -m  包含指定清單文件中的清單信息

    -e  爲捆綁到可執行 jar 文件的獨立應用程序

        指定應用程序入口點

    -0  僅存儲; 不使用狀況任何 ZIP 壓縮

    -M  不建立條目的清單文件

    -i  爲指定的 jar 文件生成索引信息

    -C  更改成指定的目錄幷包含其中的文件

若是有任何目錄文件, 則對其進行遞歸處理。

清單文件名, 歸檔文件名和入口點名稱的指定順序

與 'm', 'f' 和 'e' 標記的指定順序相同。

 

示例 1: 將兩個類文件歸檔到一個名爲 classes.jar 的歸檔文件中:

       jar cvf classes.jar Foo.class Bar.class

示例 2: 使用現有的清單文件 'mymanifest' 並

           將 foo/ 目錄中的全部文件歸檔到 'classes.jar' 中:

       jar cvfm classes.jar mymanifest -C foo/。

------------------------

例子：將D:\javacode\package下的pack1fa包與pack2son包歸檔（壓縮）到名爲haha.jar中

命令：jar  –cf  haha.jar  pack1fa  pack2son   (-cf : -後的順序可互換)

 

DOS中查看jar包中的內容：D:\javacode\package>jar –tf  haha.jar

 

運行jar包內的class類：（環境變量）

1、設置路徑：

D:\javacode\package>set classpath=d:\javacode\package\haha.jar

2、運行（java）：

java  pack.packageDemo  （運行pack包內的packageDemo類）