一、Object類的使用

1.java.lang.Object類的說明：

1. Object類是所Java類的根父類

2. 如果在類的宣告中未使用extends關鍵字指明其父類，則默認父類為java.lang.Object類

3. Object類中的功能(屬性、方法)就具通用性，

屬性：無

方法：equals() / toString() / getClass() /hashCode() / clone() / finalize() / wait() 、 notify()、notifyAll()

4. Object類只宣告了一個空參的構造器

2.equals()方法

equals()是一個方法，而非運算子

只能適用于參考資料型別

Object類中equals()的定義：

public boolean equals(Object obj) {
    return (this == obj);
}

說明：Object類中定義的equals()和==的作用是相同的：比較兩個物件的地址值是否相同.即兩個參考是否指向同一個物件物體，

像String、Date、File、包裝類等都重寫了Object類中的equals()方法，重寫以后，比較的不是兩個參考的地址是否相同，而是比較兩個物件的"物體內容"是否相同，

通常情況下，我們自定義的類如果使用equals()的話，也通常是比較兩個物件的"物體內容"是否相同，那么，我們就需要對Object類中的equals()進行重寫，重寫的原則：比較兩個物件的物體內容是否相同，

3.如何重寫equals()

手動重寫舉例

class User{
    String name;
    int age;
    //重寫其equals()方法
    public boolean equals(Object obj){
        if(obj == this){
            return true;
        }
        if(obj instanceof User){
            User u = (User)obj;
            return this.age == u.age && this.name.equals(u.name);
        }
        return false;
    }
}

自動重寫：用開發工具快捷鍵自動生成的，

== 運算子的使用：

1. 可以使用在基本資料型別變數和參考資料型別變數中，

2. 如果比較的是基本資料型別變數：比較兩個變數保存的資料是否相等，（不一定型別要相同）

3. 如果比較的是參考資料型別變數：比較兩個物件的地址值是否相同.即兩個參考是否指向同一個物件物體，

4. 補充： == 符號使用時，必須保證符號左右兩邊的變數型別一致，

4.toString()方法

當我們輸出一個物件的參考時，實際上就是呼叫當前物件的toString()

Object類中toString()的定義：

public String toString() {
	return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

像String、Date、File、包裝類等都重寫了Object類中的toString()方法，使得在呼叫物件的toString()時，回傳"物體內容"資訊，

自定義類也可以重寫toString()方法，當呼叫此方法時，回傳物件的"物體內容"，

5.如何重寫toString()

舉例：

//自動實作
@Override
public String toString() {
	return "Customer [name=" + name + ", age=" + age + "]";
}

6.面試題

1. final、finally、finalize的區別？

2. == 和 equals() 的區別？

二、包裝類的使用

問：為什么要有包裝類(或封裝類）？

答：為了使基本資料型別的變數具有類的特征，引入包裝類，

1.基本資料型別對應的包裝類

Byte,Short,Integer,Long,Float,Double：父類：Number

2.型別間的轉換(基本資料型別、包裝類、String)

簡易版：

基本資料型別<--->包裝類：JDK 5.0 新特性：自動裝箱 與自動拆箱

基本資料型別、包裝類--->String：呼叫String多載的valueOf(Xxx xxx)

String--->基本資料型別、包裝類：呼叫包裝類的parseXxx(String s)

注意：轉換時，可能會報NumberFormatException

應用場景舉例：

1. Vector類中關于添加元素，只定義了形參為Object型別的方法：

2. v.addElement(Object obj); //基本資料型別 --->包裝類 --->使用多型

三、單元測驗方法使用

Java中的JUnit單元測驗

IDEA:寫上@Test注解后，自動生成，

Eclipse:

步驟：

1. 中當前工程 - 右鍵擇：build path - add libraries - JUnit 4 - 下一步

2. 創建Java類，進行單元測驗，此時的Java類要求：①此類是public的 ②此類提供公共的無參的構造器

3. 此類中宣告單元測驗方法，此時的單元測驗方法：方法的權限是public,沒回傳值，沒形參

4. 此單元測驗方法上需要宣告注解：@Test,并在單元測驗類中匯入：import org.junit.Test;

5. 宣告好單元測驗方法以后，就可以在方法體內測驗相關的代碼，

6. 寫完代碼以后，左鍵雙擊單元測驗方法名，右鍵：run as - JUnit Test

說明：

1.如果執行結果沒任何例外：綠條

2.如果執行結果出現例外：紅條

四、方法的重寫

1.什么是方法的重寫(override 或 overwrite)？

子類繼承父類以后，可以對父類中同名同引數的方法，進行覆寫操作，

2. 應用

重寫以后，當創建子類物件以后，通過子類物件呼叫子父類中的同名同引數的方法時，實際執行的是子類重寫父類的方法，

3.舉例

class Circle{
	public double findArea(){}//求面積
}
class Cylinder extends Circle{
	public double findArea(){}//求表面積
}

class Account{
	public boolean withdraw(double amt){}
}
class CheckAccount extends Account{
	public boolean withdraw(double amt){}
}

4.重寫的規則

方法的宣告： 權限修飾符 回傳值型別 方法名(形參串列) throws 例外的型別{

? //方法體

? }

約定俗稱：子類中的叫重寫的方法，父類中的叫被重寫的方法，

① 子類重寫的方法的方法名和形參串列與父類被重寫的方法的方法名和形參串列相同，

② 子類重寫的方法的權限修飾符不小于父類被重寫的方法的權限修飾符

特殊情況：子類不能重寫父類中宣告為private權限的方法，

③ 回傳值型別：

父類被重寫的方法的回傳值型別是void，則子類重寫的方法的回傳值型別只能是void，

父類被重寫的方法的回傳值型別是A型別，則子類重寫的方法的回傳值型別可以是A類或A類的子類，

父類被重寫的方法的回傳值型別是基本資料型別(比如：double)，則子類重寫的方法的回傳值型別必須是相同的基本資料型別(必須也是double)，

④ 子類重寫的方法拋出的例外型別不大于父類被重寫的方法拋出的例外型別（具體放到例外處理時候講）

子類和父類中的同名同引數的方法要么都宣告為非static的（考慮重寫，要么都宣告為static的（不是重寫)，

5.面試題：區分方法的重寫和多載？

① 二者的概念：

② 多載和重寫的具體規則，

③ 多載：不表現為多型性，

重寫：表現為多型性，

多載：是指允許存在多個同名方法，而這些方法的引數不同，編譯器根據方法不同的引數表，對同名方法的名稱做修飾，對于編譯器而言，這些同名方法就成了不同的方法，它們的呼叫地址在編譯期就系結了，Java的多載是可以包括父類和子類的，即子類可以多載父類的同名不同引數的方法，

所以：對于多載而言，在方法呼叫之前，編譯器就已經確定了所要呼叫的方法，這稱為“早系結”或“靜態系結”

而對于多型，只等到方法呼叫的那一刻，解釋運行器才會確定所要呼叫的具體方法，這稱為“晚系結”或“動態系結”

參考一句Bruce Eckel的話：“不要犯傻，如果它不是晚系結，它就不是多型，”

五、面向物件的特征二：繼承性

1.為什么要有類的繼承性？

1. 減少了代碼的冗余，提高了代碼的復用性

2. 便于功能的擴展

3. 為之后多型性的使用，提供了前提

圖示：

2.繼承性的格式

class A extends B{}

//A:子類、派生類、subclass

//B:父類、超類、基類、superclass

3.子類繼承父類以后有哪些不同？

1. 體現：一旦子類A繼承父類B以后，子類A中就獲取了父類B中宣告的所有的屬性和方法，

2. 子類繼承父類以后，還可以宣告自己特有的屬性或方法：實作功能的拓展，

特別的，父類中宣告為private的屬性或方法，子類繼承父類以后，仍然認為獲取了父類中私的結構，只因為封裝性的影響，使得子類不能直接呼叫父類的結構而已，

子類和父類的關系，不同于子集和集合的關系，

extends：延展、擴展

4.Java中繼承性的說明

1. 一個類可以被多個子類繼承，

2. Java中類的單繼承性：一個類只能有一個父類

3. 子父類是相對的概念，

4. 子類直接繼承的父類，稱為：直接父類，間接繼承的父類稱為：間接父類

5. 子類繼承父類以后，就獲取了直接父類以及所間接父類中宣告的屬性和方法

圖示：

5.java.lang.Object類的理解

1. 如果我們沒顯式的宣告一個類的父類的話，則此類繼承于java.lang.Object類，

2. 所有的java類（除java.lang.Object類之外都直接或間接的繼承于java.lang.Object類，

3. 意味著，所的java類具有java.lang.Object類宣告的功能，

六、面向物件的特征三：多型性

理解：可以理解為一個事物的多種形態，

1.何為多型性：

物件的多型性：父類的參考指向子類的物件（或子類的物件賦給父類的參考）

舉例：

Person p = new Man();
Object obj = new Date();

2.多型性的使用：虛擬方法呼叫

有了物件的多型性以后，我們在編譯期，只能呼叫父類中宣告的方法，但在運行期，我們實際執行的是子類重寫父類的方法，

總結：編譯，看左邊；運行，看右邊，

3.多型性的使用前提

① 類的繼承關系 ② 方法的重寫

4.多型性的應用舉例：

//舉例一：
public void func(Animal animal){//Animal animal = new Dog();
    animal.eat();
    animal.shout();
}
//舉例二：
public void method(Object obj){
}
//舉例三：
class Driver{
    public void doData(Connection conn){//conn = new MySQlConnection(); / conn = new OracleConnection();
        //規范的步驟去操作資料
        //        conn.method1();
        //        conn.method2();
        //        conn.method3();
    }
}

5.多型性使用的注意點

物件的多型性，只適用于方法，不適用于屬性（編譯和運行都看左邊）

6.關于向上轉型與向下轉型

1. 向上轉型：多型

2. 向下轉型：

3. 為什么使用向下轉型：有了物件的多型性以后，記憶體中實際上是加載了子類特有的屬性和方法的，但是由于變數宣告為父型別別，導致編譯時，只能呼叫父類中宣告的屬性和方法，子類特有的屬性和方法不能呼叫，如何才能呼叫子類特有的屬性和方法？使用向下轉型，

4. 如何實作向下轉型：使用強制型別轉換符：()

5. 使用時的注意點：

   1. 使用強轉時，可能出現ClassCastException的例外，
   2. 為了避免在向下轉型時出現ClassCastException的例外，我們在向下轉型之前，先進行instanceof的判斷，一旦回傳true，就進行向下轉型，如果回傳false，不進行向下轉型，

6. instanceof的使用：

   1. a instanceof A:判斷物件a是否是類A的實體，如果是，回傳true；如果不是，回傳false，
   2. 如果 a instanceof A回傳true,則 a instanceof B也回傳true.其中，類B是類A的父類，
   3. 要求a所屬的類與類A必須是子類和父類的關系，否則編譯錯誤，

7. 圖示

8. 面試題

談你對多型性的理解？

1. 實作代碼的通用性，

2. Object類中定義的public boolean equals(Object obj){ }

3. 抽象類、介面的使用肯定體現了多型性，（抽象類、介面不能實體化）

JDBC:使用java程式操作(獲取資料庫連接、CRUD)資料庫(MySQL、Oracle、DB2、SQL Server)

多型是編譯時行為還是運行時行為？

答：多型是運行時行為：因為程式只能在程式運行的時候才能決定呼叫哪個物件的方法

七、關鍵字 super

super 關鍵字可以理解為：父類的

可以用來呼叫的結構：屬性、方法、構造器

1.super呼叫屬性、方法

1. 我們可以在子類的方法或構造器中，通過使用"super.屬性"或"super.方法"的方式，顯式的呼叫父類中宣告的屬性或方法，但是，通常情況下，我們習慣省略"super."

2. 特殊情況：當子類和父類中定義了同名的屬性時，我們要想在子類中呼叫父類中宣告的屬性，則必須顯式的使用"super.屬性"的方式，表明呼叫的是父類中宣告的屬性，

3. 特殊情況：當子類重寫了父類中的方法以后，我們想在子類的方法中呼叫父類中被重寫的方法時，則必須顯式的使用"super.方法"的方式，表明呼叫的是父類中被重寫的方法，

2.super呼叫構造器

1. 我們可以在子類的構造器中顯式的使用"super(形參串列)"的方式，呼叫父類中宣告的指定的構造器，

2. "super(形參串列)"的使用，必須宣告在子類構造器的首行！

3. 我們在類的構造器中，針對于"this(形參串列)"或"super(形參串列)"只能二一，不能同時出現，

4. 在構造器的首行，沒顯式的宣告"this(形參串列)"或"super(形參串列)"，則默認呼叫的是父類中空參的構造器：super()，

5. 在類的多個構造器中，至少一個類的構造器中使用了"super(形參串列)"，呼叫父類中的構造器，

八、子類物件實體化全程序

1.從結果上看：繼承性

1. 子類繼承父類以后，就獲取了父類中宣告的屬性或方法，

2. 創建子類的物件，在堆空間中，就會加載所有父類中宣告的屬性，

2.從程序上看

當我們通過子類的構造器創建子類物件時，我們一定會直接或間接的呼叫其父類的構造器，進而呼叫父類的父類的構造器，...直到呼叫了java.lang.Object類中空參的構造器為止，正因為加載過所有的父類的結構，所以才可以看到記憶體中父類中的結構，子類物件才可以考慮進行呼叫，

圖示：

3.強調說明

雖然創建子類物件時，呼叫了父類的構造器，但是自始至終就創建過一個物件，即為new的子類物件，

Dog dog = new Dog("花花","哈哈")

標籤：Java

上一篇：Java檔案注釋（拓展）

下一篇：Java基礎