🌹作者:云小逸
📝個人主頁:云小逸的主頁
📝Github:云小逸的Github
🤟motto:要敢于一個人默默的面對自己，強大自己才是核心。不要等到什么都沒有了，才下定決心去做。種一顆樹，最好的時間是十年前，其次就是現在！學會自己和解，與過去和解，努力愛自己。==希望春天來之前，我們一起面朝大海，春暖花開！==🤟
👏專欄：C++👏 👏專欄：Java語言👏
👏專欄：C語言初階👏👏專欄：數據結構👏

文章目錄

• 前言
• 1.繼承
• • a.繼承概述：
  • • （1）什么是繼承？
    • （2）繼承的格式：
    • （3）繼承后子類的特點？
    • （4）繼承的核心優點：
  • b.繼承的設計規范、內存運行原理
  • c.繼承的特點
  • • 1.子類可以繼承父類的屬性和行為，但是子類不能繼承==父類的構造器==。
    • 2.子類可以繼承父類私有成員嗎？
    • 3.子類可以直接用子類名訪問父類靜態成員。那么子類繼承了父類靜態成員嗎？？
    • 4.Java是單繼承模式：一個類只能繼承一個直接父類。
    • 5.Java不支持多繼承、但是支持多層繼承。
    • 6.Java中所有的類都是Object類的子類。
  • d.繼承后：成員變量、成員方法的訪問特點
  • • （1）就近原則
    • （2）如果子父類中，出現了重名的成員，會優先使用子類的，此時如果一定要在子類中使用父類的怎么辦？
  • e.繼承后：方法重寫
  • • （1）概念：
    • （2）重寫方法建議加上一個重寫校驗注解：@Override
    • （3）方法重寫注意事項和要求：
  • f.繼承后：子類構造器的特點
  • • 特點：
    • 為什么？
    • 代碼層面：
  • g.繼承后：子類構造器訪問父類有參構造器
  • • （1）super調用父類有參數構造器的作用：
    • （2）如果父類中沒有無參數構造器，只有有參構造器，會出現什么現象呢？
    • （3）如何解決？
    • 總結：
  • h.this、super使用總結
  • • this,super的意義：
    • this(...)，super(...)的作用:
• 2.封裝
• • 封裝的基本思想：
  • 封裝的原則：
  • 如何更好的封裝呢？
• 3.多態：
• • a.什么是多態？
  • b.多態的前提：
  • • 1.有繼承關系\實現關系
    • 2.有父類引用指向子類對象。
  • c.多態的格式：
  • d. 多態的使用場景
  • • 代碼示例：
  • f.多態的運行特點
  • g.多態的優勢
  • h.多態的弊端：
  • i.引用類型轉換
  • • （1）為什么要轉型
    • （2） 向上轉型（自動轉換）
    • • 使用格式：
    • （3） 向下轉型（強制轉換）
    • • 使用格式：
    • （4）案例演示
    • （5）轉型的異常
    • （6）instanceof關鍵字
    • （7）instanceof新特性
    • （8）強制類型轉換能解決什么問題?
• 最后
• • **愿我們一起加油，奔向更美好的未來，愿我們從懵懵懂懂的一枚==菜鳥==逐漸成為==大佬==。加油，為自己點贊！** ? 注：本篇文章是本人在b站學習黑馬程序員的學習筆記，無任何商用用途，僅為自己和讀者的Java語言學習的學習資料。 ?

---

前言

今天這篇文章主要講述Java語言的三大特征：繼承、封裝、多態。
——————————————————————————————
首先先摘抄上幾句話：獻給堅持創作的我和點開這篇文章希望進步的你:
1.一旦你出現明天開始努力的想法，而不是從現在開始，那明天的你大概率還是虛度光陰。

2.真正讓你成長的，永遠是那些讓你害怕，逃避，疼痛的事情。

3.我們對年齡的恐懼，其實并不在于年齡增長所來的蒼老。而是恐懼隨著年齡的增長，我們仍然一無所得。

4.你不跳出舒適區，把薪酬都用在吃喝玩樂的陷阱里，日復一日地隨波逐流，突破口只會離你越來越遠。

5.以前我覺得成績不重要。清華、北大、復旦、交大°，只能代表學生時代的成就。后來我發現，努力是種習慣，它會貫穿終生。

---

1.繼承

a.繼承概述：

（1）什么是繼承？

Java允許一個類通過extends與另一個類建立父子關系，這就是繼承。

（2）繼承的格式：

子類 extends父類

public class Student extends People {}

Student稱為子類（派生類），People稱為父類(基類 或超類)。

（3）繼承后子類的特點？

子類繼承父類，子類可以得到父類的屬性和行為，子類可以使用。
Java中子類更強大

（4）繼承的核心優點：

提高代碼的復用性，多個子類的相同代碼可以放在父類中，增強了類的擴展性。

b.繼承的設計規范、內存運行原理

設計規范：子類共用屬性和行為放在父類，子類獨有屬性和行為放在子類自己那里。

c.繼承的特點

1.子類可以繼承父類的屬性和行為，但是子類不能繼承父類的構造器。

類有自己的構造器，父類構造器用于初始化父類對象。

2.子類可以繼承父類私有成員嗎？

有爭議的.
通常意義上說Java的子類不能繼承父類的private變量。因為不能直接的訪問父類的private變量.但是當你實例化子類時，在內存中有一個父類的私有變量已經放到了內存中。這一點通過子類訪問父類的public或protect方法可以訪問到父類的私有變量。

3.子類可以直接用子類名訪問父類靜態成員。那么子類繼承了父類靜態成員嗎？？

有爭議的知識點。
子類可以直接使用父類的靜態成員（共享）
但個人認為：子類不能繼承父類的靜態成員。（共享并非繼承）

4.Java是單繼承模式：一個類只能繼承一個直接父類。

單繼承：子類只能繼承一個直接父類
不支持多繼承：子類不能同時繼承多個父類

public class 子類C extends 父類A , 父類B{public static void main(String[] args) {子類 z = new 子類();z.method(); // 復習啥？出現二義性//聽哪個爸爸的呢？java懵了！因此不支持多繼承} }

5.Java不支持多繼承、但是支持多層繼承。

子類 A 繼承父類 B ，父類B 可以 繼承父類 C

6.Java中所有的類都是Object類的子類。

Java中所有類，要么直接繼承了Object , 要么默認繼承了Object , 要么間接繼承了Object, Object是祖宗類。

d.繼承后：成員變量、成員方法的訪問特點

（1）就近原則

先子類局部范圍找
然后子類成員范圍找
然后父類成員范圍找，如果父類范圍還沒有找到則報錯。

（2）如果子父類中，出現了重名的成員，會優先使用子類的，此時如果一定要在子類中使用父類的怎么辦？

this.子類自己的成員變量
super.父類成員變量/父類成員方法
格式：super.父類成員變量/父類成員方法

e.繼承后：方法重寫

（1）概念：

子類重寫了一個申明與父類一樣的方法，覆蓋父類的方法。子類認為父類的該方法不好用，以后用自己重寫的方法。

（2）重寫方法建議加上一個重寫校驗注解：@Override

作用1：要求必須是正確重寫的才不報錯
作用2：可讀性好

（3）方法重寫注意事項和要求：

1.重寫方法的名稱和形參列表必須與父類被重寫方法的名稱和形參列表一致
2.私有方法不能重寫
3.靜態方法不能重寫
4.重寫方法的權限 >= 被重寫方法的訪問權限。

f.繼承后：子類構造器的特點

特點：

子類的全部構造器默認都會先訪問父類的無參數構造器，再執行自己的構造器

為什么？

子類在初始化的時候，有可能會使用到父類中的數據，如果父類沒有完成初始化，子類將無法使用父類的數據。
子類初始化之前，一定要調用父類構造器先完成父類數據空間的初始化。
簡要理解：
先有爸爸才有兒子。 先調用它爸爸的構造器初始化父類的數據，再調用自己的構造器初始化自己的數據。

代碼層面：

默認子類構造器的第一行都有一個super() 訪問父類的無參數構造器，寫不寫都有
。

g.繼承后：子類構造器訪問父類有參構造器

（1）super調用父類有參數構造器的作用：

初始化繼承自父類的數據。

（2）如果父類中沒有無參數構造器，只有有參構造器，會出現什么現象呢？

會報錯。因為子類默認是調用父類無參構造器的。

（3）如何解決？

子類構造器中可以通過書寫 super(…)，手動調用父類的有參數構造器

總結：

調用父類有參數構造器，初始化繼承自父類的數據。
super(…) 根據參數調用父類構造器

h.this、super使用總結

this,super的意義：

this：代表本類對象的引用；super：代表父類存儲空間的標識。
this訪問子類當前對象的成員。super：在子類方法中指定訪問父類的成員。

this(…)，super(…)的作用:

this(…) : 訪問本類兄弟構造器
super(…):在本類構造器中指定訪問父類的構造器
注意事項：super(…) 必須放在第一行，this(…) 也必須在第一行。因此2者不能共存一個構造器中。

2.封裝

封裝的基本思想：

決定屬性和行為歸屬誰的問題定義人類（名稱，年齡，吃飯、睡覺）定義圓類（半徑，畫圓）定義門類（開門，高寬）定義票類（ 票價，地址，買票）

封裝的原則：

對象代表什么，就得封裝對應的數據，并提供數據對應的行為。

如何更好的封裝呢？

成員變量建議private私有化，只能本類訪問了。合理暴露：提供成套的getter和setter方法暴露取值和賦值

3.多態：

a.什么是多態？

多態就是同一個行為有很多個表示形態，我們知道三角形是一個形態，四邊形也是一個形態，這里的多態其實就是一個端口，多態的出現其實就是對多種端口形態的體現。
更準確的說是：對象的多種形態。

b.多態的前提：

1.有繼承關系\實現關系

2.有父類引用指向子類對象。

Fu f=new Zi();

有繼承關系，子類對象是可以賦值給父類類型的變量。例如Animal是一個動物類型，而Cat是一個貓類型。Cat繼承了Animal，Cat對象也是Animal類型，自然可以賦值給父類類型的變量。

c.多態的格式：

父類類型 變量名 = new 子類/實現類構造器; 變量名.方法名();

d. 多態的使用場景

如果沒有多態，在下圖中register方法只能傳遞學生對象，其他的Teacher和administrator對象是無法傳遞給register方法方法的，在這種情況下，只能定義三個不同的register方法分別接收學生，老師和管理員。

有了多態之后，方法的形參就可以定義為共同的父類Person。

要注意的是：

• 當一個方法的形參是一個類，我們可以傳遞這個類所有的子類對象。
• 當一個方法的形參是一個接口，我們可以傳遞這個接口所有的實現類對象（后面會學）。
• 而且多態還可以根據傳遞的不同對象來調用不同類中的方法。

代碼示例：

父類： public class Person {private String name;private int age;空參構造帶全部參數的構造get和set方法public void show(){System.out.println(name + ", " + age);} }子類1： public class Administrator extends Person {@Overridepublic void show() {System.out.println("管理員的信息為：" + getName() + ", " + getAge());} }子類2： public class Student extends Person{@Overridepublic void show() {System.out.println("學生的信息為：" + getName() + ", " + getAge());} }子類3： public class Teacher extends Person{@Overridepublic void show() {System.out.println("老師的信息為：" + getName() + ", " + getAge());} }測試類： public class Test {public static void main(String[] args) {//創建三個對象，并調用register方法Student s = new Student();s.setName("張三");s.setAge(18);Teacher t = new Teacher();t.setName("王建國");t.setAge(30);Administrator admin = new Administrator();admin.setName("管理員");admin.setAge(35);register(s);register(t);register(admin);}//這個方法既能接收老師，又能接收學生，還能接收管理員//只能把參數寫成這三個類型的父類public static void register(Person p){p.show();} }

f.多態的運行特點

調用成員變量時：編譯看左邊，運行看左邊
調用成員方法時：編譯看左邊，運行看右邊
案例理解：

//創建對象（多態方式）//Fu f = new Zi();Animal a = new Dog();//調用成員變量：編譯看左邊，運行也看左邊//編譯看左邊：javac編譯代碼的時候，會看左邊的父類中有沒有這個變量，如果有，編譯成功，如果沒有編譯失敗。//運行也看左邊：java運行代碼的時候，實際獲取的就是左邊父類中成員變量的值System.out.println(a.name);//動物//調用成員方法：編譯看左邊，運行看右邊//編譯看左邊：javac編譯代碼的時候，會看左邊的父類中有沒有這個方法，如果有，編譯成功，如果沒有編譯失敗。//運行看右邊：java運行代碼的時候，實際上運行的是子類中的方法。a.show();///Dog --- show方法//理解：//Animal a = new Dog();//現在用a去調用變量和方法的呀？是的//而a是Animal類型的，所以默認都會從Animal這個類中去找//成員變量：在子類的對象中，會把父類的成員變量也繼承下的。父：name 子：name//成員方法：如果子類對方法進行了重寫，那么在虛方法表中是會把父類的方法進行覆蓋的。

編譯的時候都會先看一看父類有沒有這個成員變量或者成員方法。這也成了多態的弊端

g.多態的優勢

方法中，使用父類作為參數，可以接收所有子類對象

Animal a = new Dog();a.eat();

當想使用其他子類的時候，直接將第一行中的Dog改為其他子類就好了，
其他不需要改變，這個就是多態的優勢。

h.多態的弊端：

不能使用子類的特有功能

//創建對象Animal a = new Dog();//編譯看左邊，運行看右邊a.eat();//多態的弊端//不能調用子類的特有功能//報錯的原因？//當調用成員方法的時候，編譯看左邊，運行看右邊//那么在編譯的時候會先檢查左邊的父類中有沒有這個方法，如果沒有直接報錯。//a.lookHome();//lookHom()是Dog子類的特有的功能

lookHom()是Dog子類的特有的功能，使用多態后就不可以使用了。

i.引用類型轉換

（1）為什么要轉型

使用多態后就無法訪問子類獨有功能了。

當使用多態方式調用方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤。也就是說，不能調用子類擁有，而父類沒有的方法。編譯都錯誤，更別說運行了。這也是多態給我們帶來的一點"小麻煩"。所以，想要調用子類特有的方法，必須做向下轉型。

回顧基本數據類型轉換

• 自動轉換: 范圍小的賦值給范圍大的.自動完成:double d = 5;
• 強制轉換: 范圍大的賦值給范圍小的,強制轉換:int i = (int)3.14

多態的轉型分為向上轉型（自動轉換）與向下轉型（強制轉換）兩種。

（2） 向上轉型（自動轉換）

• 向上轉型：多態本身是子類類型向父類類型向上轉換（自動轉換）的過程，這個過程是默認的。
  當父類引用指向一個子類對象時，便是向上轉型。

使用格式：

父類類型 變量名 = new 子類類型(); 如：Animal a = new Cat();

原因是：父類類型相對與子類來說是大范圍的類型，Animal是動物類，是父類類型。Cat是貓類，是子類類型。Animal類型的范圍當然很大，包含一切動物。所以子類范圍小可以直接自動轉型給父類類型的變量。

（3） 向下轉型（強制轉換）

• 向下轉型：父類類型向子類類型向下轉換的過程，這個過程是強制的。
  一個已經向上轉型的子類對象，將父類引用轉為子類引用，可以使用強制類型轉換的格式，便是向下轉型。

使用格式：

子類類型 變量名 = (子類類型) 父類變量名; 如:Aniaml a = new Cat();Cat c =(Cat) a;

（4）案例演示

當使用多態方式調用方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤。也就是說，不能調用子類擁有，而父類沒有的方法。編譯都錯誤，更別說運行了。這也是多態給我們帶來的一點"小麻煩"。所以，想要調用子類特有的方法，必須做向下轉型。

轉型演示，代碼如下：

定義類：

abstract class Animal { abstract void eat(); } class Cat extends Animal { public void eat() { System.out.println("吃魚"); } public void catchMouse() { System.out.println("抓老鼠"); } } class Dog extends Animal { public void eat() { System.out.println("吃骨頭"); } public void watchHouse() { System.out.println("看家"); } }

定義測試類：

public class Test {public static void main(String[] args) {// 向上轉型 Animal a = new Cat(); a.eat(); // 調用的是 Cat 的 eat// 向下轉型 Cat c = (Cat)a; c.catchMouse(); // 調用的是 Cat 的 catchMouse} }

（5）轉型的異常

轉型的過程中，一不小心就會遇到這樣的問題，請看如下代碼：

public class Test {public static void main(String[] args) {// 向上轉型 Animal a = new Cat(); a.eat(); // 調用的是 Cat 的 eat// 向下轉型 Dog d = (Dog)a; d.watchHouse(); // 調用的是 Dog 的 watchHouse 【運行報錯】} }

這段代碼可以通過編譯，但是運行時，卻報出了 ClassCastException ，類型轉換異常！這是因為，明明創建了Cat類型對象，運行時，當然不能轉換成Dog對象的。

（6）instanceof關鍵字

為了避免ClassCastException的發生，Java提供了 instanceof 關鍵字，給引用變量做類型的校驗，格式如下：

變量名 instanceof 數據類型 如果變量屬于該數據類型或者其子類類型，返回true。 如果變量不屬于該數據類型或者其子類類型，返回false。

所以，轉換前，我們最好先做一個判斷，代碼如下：

public class Test {public static void main(String[] args) {// 向上轉型 Animal a = new Cat(); a.eat(); // 調用的是 Cat 的 eat// 向下轉型 if (a instanceof Cat){Cat c = (Cat)a; c.catchMouse(); // 調用的是 Cat 的 catchMouse} else if (a instanceof Dog){Dog d = (Dog)a; d.watchHouse(); // 調用的是 Dog 的 watchHouse}} }

（7）instanceof新特性

JDK14的時候提出了新特性，把判斷和強轉合并成了一行

//新特性 //先判斷a是否為Dog類型，如果是，則強轉成Dog類型，轉換之后變量名為d //如果不是，則不強轉，結果直接是false if(a instanceof Dog d){d.lookHome(); }else if(a instanceof Cat c){c.catchMouse(); }else{System.out.println("沒有這個類型，無法轉換"); }

（8）強制類型轉換能解決什么問題?

Person p=new Student(); Student s = ( Student)p;

●可以轉換成真正的子類類型，從而調用子類獨有功能。
●轉換類型與真實對象類型不一致會報錯
●轉換的時候用instanceof關鍵字進行判斷

最后

十分感謝你可以耐著性子把它讀完和我可以堅持寫到這里，摘抄幾句話，對你，也對我：
1.別把安全感建立在別人身上，那樣就等于把自己人生的選擇權，交給了別人。

2.要么努力到出類拔萃，要么就懶得樂知天命。最怕你見識打開了，可努力又跟不上，骨子里清高至極，性格上又軟弱無比。

3.想要過什么樣的生活，就得有什么樣的代價。我沒有承擔那種代價的能力，所以我甘愿選擇默默無聞的平凡。有人活得不平凡，而你只是沒看到他的代價而已;何況活成那種不平凡，是沒有回頭路可走的。
——七董年

沒有人會關心你付出過多少努力，撐得累不累，摔得痛不痛，他們只會看你最后站在什么位置，然后羨慕或鄙夷。

5.重蹈覆轍的下場就是自取其辱，失而復得的東西根本回不到當初，重讀一本書可能會有新的感悟，但不會有新的結局。

最后如果覺得我寫的還不錯，請不要忘記點贊?，收藏?，加關注?哦(｡･ω･｡)

愿我們一起加油，奔向更美好的未來，愿我們從懵懵懂懂的一枚菜鳥逐漸成為大佬。加油，為自己點贊！
?
注：本篇文章是本人在b站學習黑馬程序員的學習筆記，無任何商用用途，僅為自己和讀者的Java語言學習的學習資料。
?

總結

以上是生活随笔為你收集整理的Java语言知识大盘点（期末总复习）三的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。