三：面向物件：★★★★★

特點：1：將複雜的事情簡單化。

2：面向物件將以前的過程中的執行者，變成了指揮者。

3：面向物件這種思想是符合現在人們思考習慣的一種思想。

 

過程和物件在我們的程式中是如何體現的呢？過程其實就是函式；物件是將函式等一些內容進行了封裝。

 

匿名物件使用場景：

1：當對方法只進行一次呼叫的時候，可以使用匿名物件。

2：當物件對成員進行多次呼叫時，不能使用匿名物件。必須給物件起名字。

 

在類中定義其實都稱之為成員。成員有兩種：

1：成員變數：其實對應的就是事物的屬性。

2：成員函式：其實對應的就是事物的行為。

 

所以，其實定義類，就是在定義成員變數和成員函式。但是在定義前，必須先要對事物進行屬性和行為的分析，才可以用程式碼來體現。

 

private int age;//私有的訪問許可權最低，只有在本類中的訪問有效。

注意：私有僅僅是封裝的一種體現形式而已。

 

私有的成員：其他類不能直接建立物件訪問，所以只有通過本類對外提供具體的訪問方式來完成對私有的訪問，可以通過對外提供函式的形式對其進行訪問。

好處：可以在函式中加入邏輯判斷等操作，對資料進行判斷等操作。

 

總結：開發時，記住，屬性是用於儲存資料的，直接被訪問，容易出現安全隱患，所以，類中的屬性通常被私有化，並對外提供公共的訪問方法。

這個方法一般有兩個，規範寫法：對於屬性 xxx，可以使用setXXX(),getXXX()對其進行操作。

 

類中怎麼沒有定義主函式呢？

注意：主函式的存在，僅為該類是否需要獨立執行，如果不需要，主函式是不用定義的。

主函式的解釋：保證所在類的獨立執行，是程式的入口，被jvm呼叫。

 

成員變數和區域性變數的區別：

1：成員變數直接定義在類中。

   區域性變數定義在方法中，引數上，語句中。

2：成員變數在這個類中有效。

區域性變數只在自己所屬的大括號內有效，大括號結束，區域性變數失去作用域。

3：成員變數存在於堆記憶體中，隨著物件的產生而存在，消失而消失。

區域性變數存在於棧記憶體中，隨著所屬區域的執行而存在，結束而釋放。

 

建構函式：用於給物件進行初始化，是給與之對應的物件進行初始化，它具有針對性，函式中的一種。

特點：

1：該函式的名稱和所在類的名稱相同。

2：不需要定義返回值型別。

3：該函式沒有具體的返回值。

記住：所有物件建立時，都需要初始化才可以使用。

 

注意事項：一個類在定義時，如果沒有定義過建構函式，那麼該類中會自動生成一個空引數的建構函式，為了方便該類建立物件，完成初始化。如果在類中自定義了建構函式，那麼預設的建構函式就沒有了。

 

一個類中，可以有多個建構函式，因為它們的函式名稱都相同，所以只能通過引數列表來區分。所以，一個類中如果出現多個建構函式。它們的存在是以過載體現的。

 

建構函式和一般函式有什麼區別呢？

1：兩個函式定義格式不同。

2：建構函式是在物件建立時，就被呼叫，用於初始化，而且初始化動作只執行一次。

    一般函式，是物件建立後，需要呼叫才執行，可以被呼叫多次。

   

什麼時候使用建構函式呢？

分析事物時，發現具體事物一出現，就具備了一些特徵，那就將這些特徵定義到建構函式內。

 

構造程式碼塊和建構函式有什麼區別？

構造程式碼塊：是給所有的物件進行初始化，也就是說，所有的物件都會呼叫一個程式碼塊。只要物件一建立。就會呼叫這個程式碼塊。

建構函式：是給與之對應的物件進行初始化。它具有針對性。

 

Person p = new Person();

建立一個物件都在記憶體中做了什麼事情？

1：先將硬碟上指定位置的Person.class檔案載入進記憶體。

2：執行main方法時，在棧記憶體中開闢了main方法的空間(壓棧-進棧)，然後在main方法的棧區分配了一個變數p。

3：在堆記憶體中開闢一個實體空間，分配了一個記憶體首地址值。new

4：在該實體空間中進行屬性的空間分配，並進行了預設初始化。

5：對空間中的屬性進行顯示初始化。

6：進行實體的構造程式碼塊初始化。

7：呼叫該實體對應的建構函式，進行建構函式初始化。（）

8：將首地址賦值給p ，p變數就引用了該實體。(指向了該物件)

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

封 裝（面向物件特徵之一）：是指隱藏物件的屬性和實現細節，僅對外提供公共訪問方式。

好處：將變化隔離；便於使用；提高重用性；安全性。

封裝原則：將不需要對外提供的內容都隱藏起來，把屬性都隱藏，提供公共方法對其訪問。

 

this:代表物件。就是所在函式所屬物件的引用。

this到底代表什麼呢？哪個物件呼叫了this所在的函式，this就代表哪個物件，就是哪個物件的引用。

開發時，什麼時候使用this呢？

在定義功能時，如果該功能內部使用到了呼叫該功能的物件，這時就用this來表示這個物件。

 

this 還可以用於建構函式間的呼叫。

呼叫格式：this(實際引數)；

this物件後面跟上 .  呼叫的是成員屬性和成員方法(一般方法)；

this物件後面跟上 () 呼叫的是本類中的對應引數的建構函式。

 

注意：用this呼叫建構函式，必須定義在建構函式的第一行。因為建構函式是用於初始化的，所以初始化動作一定要執行。否則編譯失敗。

 

static：★★★ 關鍵字，是一個修飾符，用於修飾成員(成員變數和成員函式)。

特點：

1，想要實現物件中的共性資料的物件共享。可以將這個資料進行靜態修飾。

2，被靜態修飾的成員，可以直接被類名所呼叫。也就是說，靜態的成員多了一種呼叫方式。類名.靜態方式。

3，靜態隨著類的載入而載入。而且優先於物件存在。

 

弊端：

1，有些資料是物件特有的資料，是不可以被靜態修飾的。因為那樣的話，特有資料會變成物件的共享資料。這樣對事物的描述就出了問題。所以，在定義靜態時，必須要明確，這個資料是否是被物件所共享的。

2，靜態方法只能訪問靜態成員，不可以訪問非靜態成員。

因為靜態方法載入時，優先於物件存在，所以沒有辦法訪問物件中的成員。

3，靜態方法中不能使用this，super關鍵字。

因為this代表物件，而靜態在時，有可能沒有物件，所以this無法使用。

4，主函式是靜態的。

 

什麼時候定義靜態成員呢？或者說：定義成員時，到底需不需要被靜態修飾呢？

成員分兩種：

1，成員變數。（資料共享時靜態化）

該成員變數的資料是否是所有物件都一樣：

如果是，那麼該變數需要被靜態修飾，因為是共享的資料。

如果不是，那麼就說這是物件的特有資料，要儲存到物件中。

2，成員函式。（方法中沒有呼叫特有資料時就定義成靜態）

如果判斷成員函式是否需要被靜態修飾呢？

只要參考，該函式內是否訪問了物件中的特有資料：

如果有訪問特有資料，那方法不能被靜態修飾。

如果沒有訪問過特有資料，那麼這個方法需要被靜態修飾。

 

成員變數和靜態變數的區別：

1，成員變數所屬於物件。所以也稱為例項變數。

靜態變數所屬於類。所以也稱為類變數。

2，成員變數存在於堆記憶體中。

靜態變數存在於方法區中。

3，成員變數隨著物件建立而存在。隨著物件被回收而消失。

靜態變數隨著類的載入而存在。隨著類的消失而消失。

4，成員變數只能被物件所呼叫 。

靜態變數可以被物件呼叫，也可以被類名呼叫。

所以，成員變數可以稱為物件的特有資料，靜態變數稱為物件的共享資料。

 

靜態的注意：靜態的生命週期很長。

靜態程式碼塊：就是一個有靜態關鍵字標示的一個程式碼塊區域。定義在類中。

作用：可以完成類的初始化。靜態程式碼塊隨著類的載入而執行，而且只執行一次（new 多個物件就只執行一次）。如果和主函式在同一類中，優先於主函式執行。

 

Public：訪問許可權最大。

static：不需要物件，直接類名即可。

void：主函式沒有返回值。

Main：主函式特定的名稱。

(String[] args)：主函式的引數，是一個字串陣列型別的引數，jvm呼叫main方法時，傳遞的實際引數是 new String[0]。

 

jvm預設傳遞的是長度為0的字串陣列，我們在執行該類時，也可以指定具體的引數進行傳遞。可以在控制檯，執行該類時，在後面加入引數。引數之間通過空格隔開。jvm會自動將這些字串引數作為args陣列中的元素，進行儲存。

 

靜態程式碼塊、構造程式碼塊、建構函式同時存在時的執行順序：靜態程式碼塊 à 構造程式碼塊 à 建構函式；

 

生成Java幫助文件：命令格式：javadoc –d 資料夾名 –auther –version *.java

/**     //格式

*類描述

*@author 作者名

*@version 版本號

*/

/**

*方法描述

*@param  引數描述

*@return  返回值描述

*/

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

設計模式：解決問題最行之有效的思想。是一套被反覆使用、多數人知曉的、經過分類編目的、程式碼設計經驗的總結。使用設計模式是為了可重用程式碼、讓程式碼更容易被他人理解、保證程式碼可靠性。

 

java中有23種設計模式：

單例設計模式：★★★★★

解決的問題：保證一個類在記憶體中的物件唯一性。

比如：多程式讀取一個配置檔案時，建議配置檔案封裝成物件。會方便操作其中資料，又要保證多個程式讀到的是同一個配置檔案物件，就需要該配置檔案物件在記憶體中是唯一的。

 

Runtime()方法就是單例設計模式進行設計的。

 

如何保證物件唯一性呢？

思想：

1，不讓其他程式建立該類物件。

2，在本類中建立一個本類物件。

3，對外提供方法，讓其他程式獲取這個物件。

 

步驟：

1，因為建立物件都需要建構函式初始化，只要將本類中的建構函式私有化，其他程式就無法再建立該類物件；

2，就在類中建立一個本類的物件；

3，定義一個方法，返回該物件，讓其他程式可以通過方法就得到本類物件。（作用：可控）

 

程式碼體現：

1，私有化建構函式；

2，建立私有並靜態的本類物件；

3，定義公有並靜態的方法，返回該物件。

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

//餓漢式

class Single{

private Single(){} //私有化建構函式。

private static Single s = new Single(); //建立私有並靜態的本類物件。

public static Single getInstance(){ //定義公有並靜態的方法，返回該物件。

return s;

}

}

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

//懶漢式:延遲載入方式。

class Single2{

private Single2(){}

private static Single2 s = null;

public static Single2 getInstance(){

if(s==null)

s = new Single2();

return s;

}

}

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

繼 承（面向物件特徵之一）

好處：

1：提高了程式碼的複用性。

2：讓類與類之間產生了關係，提供了另一個特徵多型的前提。

 

父類的由來：其實是由多個類不斷向上抽取共性內容而來的。

java中對於繼承，java只支援單繼承。java雖然不直接支援多繼承，但是保留了這種多繼承機制，進行改良。

 

單繼承：一個類只能有一個父類。

多繼承：一個類可以有多個父類。

 

為什麼不支援多繼承呢？

因為當一個類同時繼承兩個父類時，兩個父類中有相同的功能，那麼子類物件呼叫該功能時，執行哪一個呢？因為父類中的方法中存在方法體。

但是java支援多重繼承。A繼承B  B繼承C  C繼承D。

多重繼承的出現，就有了繼承體系。體系中的頂層父類是通過不斷向上抽取而來的。它裡面定義的該體系最基本最共性內容的功能。

所以，一個體系要想被使用，直接查閱該系統中的父類的功能即可知道該體系的基本用法。那麼想要使用一個體系時，需要建立物件。建議建立最子類物件，因為最子類不僅可以使用父類中的功能。還可以使用子類特有的一些功能。

 

簡單說：對於一個繼承體系的使用，查閱頂層父類中的內容，建立最底層子類的物件。

 

子父類出現後，類中的成員都有了哪些特點：

1：成員變數。

 當子父類中出現一樣的屬性時，子類型別的物件，呼叫該屬性，值是子類的屬性值。

 如果想要呼叫父類中的屬性值，需要使用一個關鍵字：super

 This：代表是本類型別的物件引用。

 Super：代表是子類所屬的父類中的記憶體空間引用。

 注意：子父類中通常是不會出現同名成員變數的，因為父類中只要定義了，子類就不用在定義了，直接繼承過來用就可以了。

2：成員函式。

當子父類中出現了一模一樣的方法時，建立子類物件會執行子類中的方法。好像父類中的方法被覆蓋掉一樣。所以這種情況，是函式的另一個特性：覆蓋(複寫，重寫)

什麼時候使用覆蓋呢？當一個類的功能內容需要修改時，可以通過覆蓋來實現。

3：建構函式。

發現子類建構函式執行時，先運行了父類的建構函式。為什麼呢?

原因：子類的所有建構函式中的第一行，其實都有一條隱身的語句super();

super(): 表示父類的建構函式，並會調用於引數相對應的父類中的建構函式。而super():是在呼叫父類中空引數的建構函式。

為什麼子類物件初始化時，都需要呼叫父類中的函式？(為什麼要在子類建構函式的第一行加入這個super()?)

因為子類繼承父類，會繼承到父類中的資料，所以必須要看父類是如何對自己的資料進行初始化的。所以子類在進行物件初始化時，先呼叫父類的建構函式，這就是子類的例項化過程。

 

注意：子類中所有的建構函式都會預設訪問父類中的空引數的建構函式，因為每一個子類構造內第一行都有預設的語句super(); 

如果父類中沒有空引數的建構函式，那麼子類的建構函式內，必須通過super語句指定要訪問的父類中的建構函式。

如果子類建構函式中用this來指定呼叫子類自己的建構函式，那麼被呼叫的建構函式也一樣會訪問父類中的建構函式。

 

問題：super()和this()是否可以同時出現的建構函式中。

兩個語句只能有一個定義在第一行，所以只能出現其中一個。

 

super()或者this():為什麼一定要定義在第一行？

因為super()或者this()都是呼叫建構函式，建構函式用於初始化，所以初始化的動作要先完成。

 

繼承的細節：

什麼時候使用繼承呢？

當類與類之間存在著所屬關係時，才具備了繼承的前提。a是b中的一種。a繼承b。狼是犬科中的一種。

英文書中，所屬關係：" is a "

注意：不要僅僅為了獲取其他類中的已有成員進行繼承。

 

所以判斷所屬關係，可以簡單看，如果繼承後，被繼承的類中的功能，都可以被該子類所具備，那麼繼承成立。如果不是，不可以繼承。

 

細節二：

在方法覆蓋時，注意兩點：

1：子類覆蓋父類時，必須要保證，子類方法的許可權必須大於等於父類方法許可權可以實現繼承。否則，編譯失敗。

2：覆蓋時，要麼都靜態，要麼都不靜態。 (靜態只能覆蓋靜態，或者被靜態覆蓋)

 

繼承的一個弊端：打破了封裝性。對於一些類，或者類中功能，是需要被繼承，或者複寫的。

這時如何解決問題呢？介紹一個關鍵字，final:最終。

 

final特點：

1：這個關鍵字是一個修飾符，可以修飾類，方法，變數。

2：被final修飾的類是一個最終類，不可以被繼承。

3：被final修飾的方法是一個最終方法，不可以被覆蓋。

4：被final修飾的變數是一個常量，只能賦值一次。

 

其實這樣的原因的就是給一些固定的資料起個閱讀性較強的名稱。

不加final修飾不是也可以使用嗎？那麼這個值是一個變數，是可以更改的。加了final，程式更為嚴謹。常量名稱定義時，有規範，所有字母都大寫，如果由多個單片語成，中間用 _ 連線。

 

抽象類: abstract

抽象：不具體，看不明白。抽象類表象體現。

在不斷抽取過程中，將共性內容中的方法宣告抽取，但是方法不一樣，沒有抽取，這時抽取到的方法，並不具體，需要被指定關鍵字abstract所標示，宣告為抽象方法。

抽象方法所在類一定要標示為抽象類，也就是說該類需要被abstract關鍵字所修飾。

 

抽象類的特點：

1：抽象方法只能定義在抽象類中，抽象類和抽象方法必須由abstract關鍵字修飾（可以描述類和方法，不可以描述變數）。

2：抽象方法只定義方法宣告，並不定義方法實現。

3：抽象類不可以被建立物件(例項化)。

4：只有通過子類繼承抽象類並覆蓋了抽象類中的所有抽象方法後，該子類才可以例項化。否則，該子類還是一個抽象類。

 

抽象類的細節：

1：抽象類中是否有建構函式？有，用於給子類物件進行初始化。

2：抽象類中是否可以定義非抽象方法？

可以。其實，抽象類和一般類沒有太大的區別，都是在描述事物，只不過抽象類在描述事物時，有些功能不具體。所以抽象類和一般類在定義上，都是需要定義屬性和行為的。只不過，比一般類多了一個抽象函式。而且比一般類少了一個建立物件的部分。

3：抽象關鍵字abstract和哪些不可以共存？final , private , static

4：抽象類中可不可以不定義抽象方法？可以。抽象方法目的僅僅為了不讓該類建立物件。

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

模板方法設計模式：

解決的問題：當功能內部一部分實現時確定，一部分實現是不確定的。這時可以把不確定的部分暴露出去，讓子類去實現。

abstract class GetTime{

public final void getTime(){ //此功能如果不需要複寫，可加final限定

long start = System.currentTimeMillis();

code(); //不確定的功能部分，提取出來，通過抽象方法實現

long end = System.currentTimeMillis();

System.out.println("毫秒是："+(end-start));

}

public abstract void code(); //抽象不確定的功能，讓子類複寫實現

}

class SubDemo extends GetTime{

public void code(){ //子類複寫功能方法

for(int y=0; y<1000; y++){

System.out.println("y");

}

}

}

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

接 口：★★★★★

1：是用關鍵字interface定義的。

2：介面中包含的成員，最常見的有全域性常量、抽象方法。

注意：介面中的成員都有固定的修飾符。

成員變數：public static final

成員方法：public abstract

interface Inter{

public static final int x = 3;

public abstract void show();

}

3：介面中有抽象方法，說明介面不可以例項化。介面的子類必須實現了介面中所有的抽象方法後，該子類才可以例項化。否則，該子類還是一個抽象類。

4：類與類之間存在著繼承關係，類與介面中間存在的是實現關係。

繼承用extends  ；實現用implements ；

5：介面和類不一樣的地方，就是，介面可以被多實現，這就是多繼承改良後的結果。java將多繼承機制通過多現實來體現。

6：一個類在繼承另一個類的同時，還可以實現多個介面。所以介面的出現避免了單繼承的侷限性。還可以將類進行功能的擴充套件。

7：其實java中是有多繼承的。介面與介面之間存在著繼承關係，介面可以多繼承介面。

 

介面都用於設計上，設計上的特點：（可以理解主機板上提供的介面）

1：介面是對外提供的規則。

2：介面是功能的擴充套件。

3：介面的出現降低了耦合性。

 

抽象類與介面：

抽象類：一般用於描述一個體系單元，將一組共性內容進行抽取，特點：可以在類中定義抽象內容讓子類實現，可以定義非抽象內容讓子類直接使用。它裡面定義的都是一些體系中的基本內容。

介面：一般用於定義物件的擴充套件功能，是在繼承之外還需這個物件具備的一些功能。

 

抽象類和介面的共性：都是不斷向上抽取的結果。

 

抽象類和介面的區別：

1：抽象類只能被繼承，而且只能單繼承。

介面需要被實現，而且可以多實現。

2：抽象類中可以定義非抽象方法，子類可以直接繼承使用。

介面中都有抽象方法，需要子類去實現。

3：抽象類使用的是  is a 關係。

介面使用的 like a 關係。

4：抽象類的成員修飾符可以自定義。

介面中的成員修飾符是固定的。全都是public的。

 

在開發之前，先定義規則，A和B分別開發，A負責實現這個規則，B負責使用這個規則。至於A是如何對規則具體實現的，B是不需要知道的。這樣這個介面的出現就降低了A和B直接耦合性。

 

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

多 態★★★★★（面向物件特徵之一）：函式本身就具備多型性，某一種事物有不同的具體的體現。

 

體現：父類引用或者介面的引用指向了自己的子類物件。//Animal a = new Cat();

多型的好處：提高了程式的擴充套件性。

多型的弊端：當父類引用指向子類物件時，雖然提高了擴充套件性，但是隻能訪問父類中具備的方法，不可以訪問子類中特有的方法。(前期不能使用後期產生的功能，即訪問的侷限性)

多型的前提：

1：必須要有關係，比如繼承、或者實現。

2：通常會有覆蓋操作。

 

多型的出現思想上也做著變化：以前是建立物件並指揮物件做事情。有了多型以後，我們可以找到物件的共性型別，直接操作共性型別做事情即可，這樣可以指揮一批物件做事情，即通過操作父類或介面實現。

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

class 畢姥爺{

void 講課(){

System.out.println("企業管理");

}

void 釣魚(){

System.out.println("釣魚");

}

}

class 畢老師 extends 畢姥爺{

void 講課(){

System.out.println("JAVA");

}

void 看電影(){

System.out.println("看電影");

}

}

class {

public static void main(String[] args) {

畢姥爺 x = new 畢老師(); //畢老師物件被提升為了畢姥爺型別。 

// x.講課();

// x.看電影();  //錯誤.

畢老師 y = (畢老師)x; //將畢姥爺型別強制轉換成畢老師型別。 

y.看電影();//在多型中，自始自終都是子類物件在做著型別的變化。

}

}

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

如果想用子類物件的特有方法，如何判斷物件是哪個具體的子類型別呢？

可以可以通過一個關鍵字 instanceof ;//判斷物件是否實現了指定的介面或繼承了指定的類

 

格式：<物件 instanceof 型別> ，判斷一個物件是否所屬於指定的型別。

Student instanceof Person = true;//student繼承了person類

 

多型在子父類中的成員上的體現的特點：

1，成員變數：在多型中，子父類成員變數同名。

在編譯時期：參考的是引用型變數所屬的類中是否有呼叫的成員。（編譯時不產生物件，只檢查語法錯誤）

執行時期：也是參考引用型變數所屬的類中是否有呼叫的成員。

簡單一句話：無論編譯和執行，成員變數參考的都是引用變數所屬的類中的成員變數。

再說的更容易記憶一些：成員變數 --- 編譯執行都看 = 左邊。

2，成員函式。

編譯時期：參考引用型變數所屬的類中是否有呼叫的方法。

執行事情：參考的是物件所屬的類中是否有呼叫的方法。

為什麼是這樣的呢？因為在子父類中，對於一模一樣的成員函式，有一個特性：覆蓋。

簡單一句：成員函式，編譯看引用型變數所屬的類，執行看物件所屬的類。

更簡單：成員函式 --- 編譯看 = 左邊，執行看 = 右邊。

3，靜態函式。

編譯時期：參考的是引用型變數所屬的類中是否有呼叫的成員。

執行時期：也是參考引用型變數所屬的類中是否有呼叫的成員。

為什麼是這樣的呢？因為靜態方法，其實不所屬於物件，而是所屬於該方法所在的類。

呼叫靜態的方法引用是哪個類的引用呼叫的就是哪個類中的靜態方法。

簡單說：靜態函式 --- 編譯執行都看 = 左邊。

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

------java.lang.Object

Object：所有類的直接或者間接父類，Java認為所有的物件都具備一些基本的共性內容，這些內容可以不斷的向上抽取，最終就抽取到了一個最頂層的類中的，該類中定義的就是所有物件都具備的功能。

 

具體方法：

1，boolean equals(Object obj)：用於比較兩個物件是否相等，其實內部比較的就是兩個物件地址。

而根據物件的屬性不同，判斷物件是否相同的具體內容也不一樣。所以在定義類時，一般都會複寫equals方法，建立本類特有的判斷物件是否相同的依據。

public boolean equals(Object obj){

if(!(obj instanceof Person))

return false;

Person p = (Person)obj;

return this.age == p.age;

}

2，String toString()：將物件變成字串；預設返回的格式：類名@雜湊值 = getClass().getName() + '@' + Integer.toHexString(hashCode())

為了物件對應的字串內容有意義，可以通過複寫，建立該類物件自己特有的字串表現形式。

public String toString(){

return "person : "+age;

}

3，Class getClass()：獲取任意物件執行時的所屬位元組碼檔案物件。

4，int hashCode()：返回該物件的雜湊碼值。支援此方法是為了提高雜湊表的效能。

 

通常equals，toString，hashCode，在應用中都會被複寫，建立具體物件的特有的內容。

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

內部類：如果A類需要直接訪問B類中的成員，而B類又需要建立A類的物件。這時,為了方便設計和訪問，直接將A類定義在B類中。就可以了。A類就稱為內部類。內部類可以直接訪問外部類中的成員。而外部類想要訪問內部類，必須要建立內部類的物件。

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

class Outer{

int num = 4;

class  Inner {

void show(){

System.out.println("inner show run "+num);

}

}

public void method(){

Inner in = new Inner();//建立內部類的物件。

in.show();//呼叫內部類的方法。

}

}

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

當內部類定義在外部類中的成員位置上，可以使用一些成員修飾符修飾 private、static。

1：預設修飾符。

直接訪問內部類格式：外部類名.內部類名 變數名 =  外部類物件.內部類物件;

Outer.Inner in = new Outer.new Inner();//這種形式很少用。

但是這種應用不多見，因為內部類之所以定義在內部就是為了封裝。想要獲取內部類物件通常都通過外部類的方法來獲取。這樣可以對內部類物件進行控制。

2：私有修飾符。

通常內部類被封裝，都會被私有化，因為封裝性不讓其他程式直接訪問。

3：靜態修飾符。

如果內部類被靜態修飾，相當於外部類，會出現訪問侷限性，只能訪問外部類中的靜態成員。

注意；如果內部類中定義了靜態成員，那麼該內部類必須是靜態的。

 

內部類編譯後的檔名為：“外部類名$內部類名.java”；

 

為什麼內部類可以直接訪問外部類中的成員呢？

那是因為內部中都持有一個外部類的引用。這個是引用是 外部類名.this

內部類可以定義在外部類中的成員位置上，也可以定義在外部類中的區域性位置上。

當內部類被定義在區域性位置上，只能訪問區域性中被final修飾的區域性變數。

 

匿名內部類：沒有名字的內部類。就是內部類的簡化形式。一般只用一次就可以用這種形式。匿名內部類其實就是一個匿名子類物件。想要定義匿名內部類：需要前提，內部類必須繼承一個類或者實現介面。

 

匿名內部類的格式：new 父類名&介面名(){ 定義子類成員或者覆蓋父類方法 }.方法。

 

匿名內部類的使用場景：

當函式的引數是介面型別引用時，如果介面中的方法不超過3個。可以通過匿名內部類來完成引數的傳遞。

其實就是在建立匿名內部類時，該類中的封裝的方法不要過多，最好兩個或者兩個以內。

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

//面試

//1

new Object(){

void show(){

System.out.println("show run");

}

}.show();

//2

Object obj = new Object(){

void show(){

System.out.println("show run");

}

};

obj.show();

 

1和2的寫法正確嗎？有區別嗎？說出原因。

寫法是正確，1和2都是在通過匿名內部類建立一個Object類的子類物件。

區別：

第一個可是編譯通過，並執行。

第二個編譯失敗，因為匿名內部類是一個子類物件，當用Object的obj引用指向時，就被提升為了

Object型別，而編譯時檢查Object類中是否有show方法，所以編譯失敗。

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

class InnerClassDemo6 {

+（static）class Inner{

void show(){}

}

public void method(){

this.new Inner().show();//可以

}

public static void main(String[] args) {//static不允許this

This.new Inner().show();//錯誤，Inner類需要定義成static

}

}

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

interface Inter{

void show();

}

class Outer{//通過匿名內部類補足Outer類中的程式碼。

public static Inter method(){

return new Inter(){

public void show(){}

};

}

}

class InnerClassDemo7 {

public static void main(String[] args) {

Outer.method().show();

/*

Outer.method():意思是：Outer中有一個名稱為method的方法，而且這個方法是靜態的。

Outer.method().show():當Outer類呼叫靜態的method方法運算結束後的結果又呼叫了show方法，意味著：method()方法運算完一個是物件，而且這個物件是Inter型別的。

*/

function (new Inter(){

public void show(){}

}); //匿名內部類作為方法的引數進行傳遞。

}

public static void function(Inter in){

in.show();

}

}