內容詳解

1 包
- 1.1 匯入包中的類
- 1.2 靜態匯入
- 1.3 創建多級包
- 1.4 包的權限訪問控制
- 1.5 常見系統包
2 繼承
- 2.1 背景
- 2.2 語法規則
- 2.3 protected關鍵字
- 2.4 復雜繼承關系
- 2.5 final關鍵字
3 多型
- 3.1 向上轉型
- 3.2 動態系結
- 3.3 方法重寫
- 3.4 如何理解多型
- 3.5 向下轉型
- 3.6 super關鍵字
- 3.7 在構造方法中呼叫重寫方法的坑

1 包

包 (package) 是組織類的一種方式.
使用包的主要目的是保證類的唯一性.

例如, 你在代碼中寫了一個 Test 類. 然后你的同事也可能寫一個 Test 類，如果出現兩個同名的類, 就會沖突, 導致代碼不能編譯通過，而如果在不同包寫同一個類就不會發生這種情況，這也是為什么會出現包，

1.1 匯入包中的類

Java 中已經提供了很多現成的類供我們使用，例如:

import java.util.Date;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2021-11-14
 * Time: 9:52
 */
public class TestDemo {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date.getTime());
    }
}

在這里插入圖片描述

這里呼叫的Date類就是Java中提供給我們的現成的類，作用是得到一個毫秒級的時間戳，我們可以直接用來創建物件并呼叫相應的方法，這里最上面的匯入是在創建物件時系統自動幫我們匯入的，我們也可以自己來匯入，

💫舉個栗子：


/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2021-11-14
 * Time: 9:52
 */
public class TestDemo {
    public static void main(String[] args) {
    //手動匯入包中的類
        java.util.Date date = new java.util.Date();
        System.out.println(date.getTime());
    }
}

如果需要使用 java.util 中的其他類, 可以使用 import java.util.*

import java.util.*;
public class Test {
    public static void main(String[] args) {
        Date date = new Date();
        // 得到一個毫秒級別的時間戳
        System.out.println(date.getTime());
   }
}

這里的*是一個通配符，會根據我們使用的類來自動匯入包里的對應類，但是這樣可能會有隱患，當兩個包里面都有這個類時，如果用通配符的話編譯器就不知道匯入的是哪個包的類了，然后就會報錯，

🔑比如

import java.util.*;
import java.sql.*;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2021-11-14
 * Time: 9:52
 */
public class TestDemo {
    public static void main(String[] args) {
        // util 和 sql 中都存在一個 Date 這樣的類, 此時就會出現歧義, 編譯出錯
        Date date = new Date();
        System.out.println(date.getTime());
    }
}

在這里插入圖片描述

1.2 靜態匯入

使用 import static 可以匯入包中的靜態的方法和欄位，

import static java.lang.System.*;
public class Test {
    public static void main(String[] args) {
        out.println("hello");
   }
}

這里用了靜態匯入后輸出前面的System就可以省略了，靜態匯入可以使代碼書寫更簡單，但是不常用，

1.3 創建多級包

基本規則

在檔案的最上方加上一個 package 陳述句指定該代碼在哪個包中.
包名需要盡量指定成唯一的名字, 通常會用公司的域名的顛倒形式(例如 com.bit.demo1 ).
包名要和代碼路徑相匹配. 例如創建 com.bit.demo1 的包, 那么會存在一個對應的路徑 com/bit/demo1 來存盤代碼.
如果一個類沒有 package 陳述句, 則該類被放到一個默認包中.

步驟：
1：右鍵 src -> 新建 -> 包
在這里插入圖片描述
2：輸入多級包名，用.隔開

3：多級包生成

注意：要想生成這種形式需要在結構設定中關掉一個設定

在這里插入圖片描述

1.4 包的權限訪問控制

類中的權限訪問控制符有 public 和 private. private 中的成員只能被類的內部使用，
如果某個成員不包含 public 和 private 關鍵字, 此時這個成員可以在包內部的其他類使用, 但是不能在包外部的類使用，

🔑舉個栗子：
在這里插入圖片描述

Demo2類訪問了同包的Demo1類中的包訪問權限的變數value，可以正常輸出

在這里插入圖片描述

Test與Demo1為不同包，訪問value就會報錯，

1.5 常見系統包

java.lang:系統常用基礎類(String、Object),此包從JDK1.1后自動匯入，
java.lang.reflect:java 反射編程包;
java.net:進行網路編程開發包，
java.sql:進行資料庫開發的支持包，
java.util:是java提供的工具程式包，(集合類等) 非常重要
java.io:I/O編程開發包，

2 繼承

2.1 背景

代碼中創建的類, 主要是為了抽象現實中的一些事物(包含屬性和方法)，有的時候客觀事物之間就存在一些關聯關系，那么在表示成類和物件的時候也會存在一定的關聯，
例如, 設計一個類表示動物

// Animal.java 
public class Animal { 
 public String name; 
 
 public Animal(String name) { 
 this.name = name; 
 } 
 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 
// Cat.java 
class Cat { 
 public String name; 
 
 public Cat(String name) { 
 this.name = name; 
 } 
 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 
// Bird.java 
class Bird { 
 public String name; 
 
 public Bird(String name) { 
 this.name = name; 
 } 
 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
 
 public void fly() { 
 System.out.println(this.name + "正在飛 ︿(￣︶￣)︿"); 
 } 
}

我們發現 Animal 和 Cat 以及 Bird 這幾個類中存在一定的關聯關系:

這三個類都具備一個相同的 eat 方法, 而且行為是完全一樣的.
這三個類都具備一個相同的 name 屬性, 而且意義是完全一樣的.
從邏輯上講, Cat 和 Bird 都是一種 Animal (is - a 語意)
這時我們就可以抽取共性放在Animal類中，在讓Cat和Bird類繼承Animal類就可以達到簡化代碼和代碼重用的作用，

2.2 語法規則

基本語法：

class 子類 extends 父類 {
}

使用 extends 指定父類.
Java 中一個子類只能繼承一個父類 (而C++/Python等語言支持多繼承).
子類會繼承父類的所有 public 的欄位和方法.
對于父類的 private 的欄位和方法, 子類中是無法訪問的.
子類的實體中, 也包含著父類的實體. 可以使用 super 關鍵字得到父類實體的參考

💫舉個栗子：

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2021-11-14
 * Time: 11:07
 */
class Animal {
    public String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
}
class Cat extends Animal {
    public Cat(String name) {
        // 使用 super 呼叫父類的構造方法.
        super(name);
    }
}
class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    public void fly() {
        System.out.println(this.name + "正在飛 ︿(￣︶￣)︿");
    }
}
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("小黑");
        cat.eat("貓糧");
        Bird bird = new Bird("圓圓");
        bird.fly();
    }
}

在Bird和Cat類中雖然沒有name成員變數和eat方法，但是當他們繼承了Animal后就自然具備了父類的成員變數和方法，可以通過參考直接呼叫，

這里如果把name用private修飾那么就會出現問題，因為private修飾的變數只能在本類中才能訪問，

在這里插入圖片描述

2.3 protected關鍵字

剛才我們發現, 如果把欄位設為 private, 子類不能訪問，但是設成 public, 又違背了我們 “封裝” 的初衷(任何位置的類都能訪問public類)，
兩全其美的辦法就是protected 關鍵字，
對于類的子類和同一個包的其他類來說, protected 修飾的欄位和方法是可以訪問的
對于其他類的呼叫者來說, protected 修飾的欄位和方法是不能訪問的

小結: Java 中對于欄位和方法共有四種訪問權限
private: 類內部能訪問, 類外部不能訪問，
默認(也叫包訪問權限): 類內部能訪問, 同一個包中的類可以訪問, 其他類不能訪問，
protected: 類內部能訪問, 子類和同一個包中的類可以訪問, 其他類不能訪問，
public : 類內部和類的呼叫者都能訪問，

在這里插入圖片描述

2.4 復雜繼承關系

剛才舉的栗子是一級繼承，事實上生活中的繼承關系可以很復雜，比如

在這里插入圖片描述

這樣就是多層繼承，我們并不希望類之間的繼承層次太復雜，一般我們不希望出現超過三層的繼承關系. 如果繼承層次太多, 就需要考慮對代碼進行重構了，

2.5 final關鍵字

之前我們知道final修飾的常量是不能修改的（也就是常量），final同樣也能用來修飾類，表示類不能被繼承，

🐾舉個栗子：
在這里插入圖片描述

🔥小知識：
我們平時是用的 String 字串類, 就是用 final 修飾的, 不能被繼承，

3 多型

3.1 向上轉型

在剛才的例子中, 我們寫了形如下面的代碼：

Bird bird = new Bird("圓圓");

這個代碼也可以寫成這個樣子

Bird bird = new Bird("圓圓"); 
Animal bird2 = bird; 
// 或者寫成下面的方式
Animal bird2 = new Bird("圓圓");

此時bird2是一個父類（Animal）參考，指向一個子類（Bird）實體，這種寫法就是向上轉型，可以理解為鳥屬于動物，即可以說圓圓是一直鳥，也可以說圓圓是一種動物，

向上轉型即向父類轉型

向上轉型發生的時機:

直接賦值
方法傳參
方法回傳

🔑方法傳參

public class Test {
    public static void main(String[] args) {
        Bird bird = new Bird("圓圓");
        feed(bird);
    }
    public static void feed(Animal animal) {
        animal.eat("谷子");
    }
}

在這里插入圖片描述
🔑方法回傳

public class Test {
    public static void main(String[] args) {
        Animal animal = findMyAnimal();
    }
    public static Animal findMyAnimal() {
        Bird bird = new Bird("圓圓");
        return bird;
    }
}

3.2 動態系結

這里我們通過一個栗子來看：

class Animal {
    public String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
}
class Cat extends Animal {
    public Cat(String name) {
        // 使用 super 呼叫父類的構造方法.
        super(name);
    }
}
class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    public void fly() {
        System.out.println(this.name + "正在飛 ︿(￣︶￣)︿");
    }
    public void eat(String food) {
        System.out.println(this.name + "瘋狂吃" + food);
    }
}
public class Test {
    public static void main(String[] args) {
        Animal bird = new Bird("花花");
        bird.eat("食物");
    }
}

我們發現我創建了一個Animal的參考指向一個Bird實體，當呼叫eat方法時，呼叫的不是Animal中的eat方法，而是我在Bird類中重寫的方法，

在 Java 中, 呼叫某個類的方法, 究竟執行了哪段代碼 (是父類方法的代碼還是子類方法的代碼) , 要看究竟這個參考指向的是父類物件還是子類物件. 這個程序是程式運行時決定的(而不是編譯期), 因此稱為動態系結，

3.3 方法重寫

針對剛才的 eat 方法來說:
子類實作父類的同名方法, 并且引數的型別和個數完全相同, 這種情況稱為覆寫/重寫/覆寫(Override).

關于重寫的注意事項

重寫和多載完全不一樣. 不要混淆.
普通方法可以重寫, static 修飾的靜態方法不能重寫.(靜態方法在類加載時就加載到記憶體中了，在整個運行程序中不變，非靜態方法在物件實體化才單獨申請記憶體空間，所以可以重寫.)
重寫中子類的方法的訪問權限不能低于父類的方法訪問權限.
重寫的方法回傳值型別不一定和父類的方法相同(但是建議最好寫成相同, 特殊情況除外).

針對重寫的方法, 可以使用 @Override 注解來顯式指定.

重寫方法快捷鍵 ctrl+o

在這里插入圖片描述

小知識：
多載和重寫的區別
1.重寫引數串列和回傳值必須與被重寫的方法一樣，多載引數串列必須有不同的引數串列，回傳值型別可以不同
2.重寫方法訪問修飾符的限制一定要大于被重寫的方法，多載可以有不同的訪問修飾符
3.重寫方法不能拋出比被重寫方法更加寬泛的例外，多載可以拋出不同的例外

3.4 如何理解多型

有了面的向上轉型, 動態系結, 方法重寫之后, 我們就可以使用多型(polypeptide) 的形式來設計程式了.我們可以寫一些只關注父類的代碼, 就能夠同時兼容各種子類的情況

💫舉個栗子：

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2021-11-13
 * Time: 下午4:35
 */
class Printf{
    String name = "ant";
    void printf(){
        System.out.println("sss");
    }
}
class Rect extends Printf{
    @Override
    public void printf() {
        System.out.println("△");
    }

}
class Cur extends Printf{
    @Override
    public void printf() {
        System.out.println("○");
    }

}
class Flower extends Printf{
    @Override
    public void printf() {
        System.out.println("?");
    }
}
public class Test {
    public static void printY(Printf pintf){

        pintf.printf();
    }
    public static void main(String[] args) {
        printY(new Cur());
        printY(new Rect());
        printY(new Flower());
    }
}

在這里插入圖片描述

利用多型可以實作一個函式根據子類重寫方法的不同產生不同的結果，
多型顧名思義, 就是 "一個參考, 能表現出多種不同形態"

使用多型的好處是什么?

類呼叫者對類的使用成本進一步降低.多型能讓類的呼叫者連這個類的型別是什么都不必知道, 只需要知道這個物件具有某個方法即可.
能夠降低代碼的 “圈復雜度”, 避免使用大量的 if - else
可擴展能力更強.如果要新增一種新的形狀, 使用多型的方式代碼改動成本也比較低

3.5 向下轉型

有時候父類中沒有子類中有的方法而又想通過父類參考呼叫子類方法時就會用到向下轉型，

🔑舉個栗子：

 Animal animal = new Bird("圓圓")
 // (Bird) 表示強制型別轉換
Bird bird = (Bird)animal; 
bird.fly();

這樣就可以執行fly方法了，但是向下轉換是有風險了，比如

Animal animal = new Cat("小貓"); 
Bird bird = (Bird)animal; 
bird.fly();

這樣就會報錯，animal 本質上參考的是一個 Cat 物件, 是不能轉成 Bird 物件的. 運行時就會拋出例外.所以, 為了讓向下轉型更安全, 我們可以先判定一下看看 animal 本質上是不是一個 Bird 實體, 再來轉換

Animal animal = new Cat("小貓"); 
if (animal instanceof Bird) { 
 Bird bird = (Bird)animal; 
 bird.fly(); 
}

instanceof 可以判定一個參考是否是某個類的實體. 如果是, 則回傳 true. 這時再進行向下轉型就比較安全了.

3.6 super關鍵字

前面的代碼中由于使用了重寫機制, 呼叫到的是子類的方法. 如果需要在子類內部呼叫父類方法怎么辦? 可以使用super 關鍵字.

public class Bird extends Animal { 
     public Bird(String name) { 
     super(name); 
 } 
 @Override 
 public void eat(String food) { 
 // 修改代碼, 讓子呼叫父類的介面. 
     super.eat(food); 
     System.out.println("我是一只小鳥"); 
     System.out.println(this.name + "正在吃" + food); 
 } 
}

小知識：super和this的區別
1.this訪問本類的屬性，如果本類沒有則從父類查找，super訪問父類的屬性，
2.this訪問本類的方法，如果本類沒有則從父類查找，super訪問父類的方法，
3.this呼叫本類構造方法，必須放在構造方法的首行，super呼叫父類構造，必須放在子類構造方法首行，
4.this表示當前方法，super不能表示當前物件，

3.7 在構造方法中呼叫重寫方法的坑

🔑舉個栗子：

class B {
    public B() {
        // do nothing
        func();
    }
    public void func() {
        System.out.println("B.func()");
    }
}
class D extends B {
    private int num = 1;
    @Override
    public void func() {
        System.out.println("D.func() " + num);
    }
}
public class Test {
    public static void main(String[] args) {
        D d = new D();
    }
}

在這里插入圖片描述

構造 D 物件的同時, 會呼叫 B 的構造方法.
B 的構造方法中呼叫了 func 方法, 此時會觸發動態系結, 會呼叫到 D 中的 func
此時 D 物件自身還沒有構造, 此時 num 處在未初始化的狀態, 值為 0

作者水平有限，若文章有任何問題歡迎私聊或留言，希望和大家一起學習進步！！！
創作不易，再次希望大家👍支持下，謝謝大家🙏

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/357095.html

標籤：java

上一篇：登錄注冊

下一篇：Java經典垃圾收集器

【Java基礎】包，繼承，多型詳解。

內容詳解

1 包

1.1 匯入包中的類

1.2 靜態匯入

1.3 創建多級包

1.4 包的權限訪問控制

1.5 常見系統包

2 繼承

2.1 背景

2.2 語法規則

2.3 protected關鍵字

2.4 復雜繼承關系

2.5 final關鍵字

3 多型

3.1 向上轉型

3.2 動態系結

3.3 方法重寫

3.4 如何理解多型

3.5 向下轉型

3.6 super關鍵字

3.7 在構造方法中呼叫重寫方法的坑