Java 面向?qū)ο笠挥[
本文轉(zhuǎn)載自微信公眾號「蝸牛互聯(lián)網(wǎng)」，作者白色蝸牛。轉(zhuǎn)載本文請聯(lián)系蝸牛互聯(lián)網(wǎng)公眾號。
本文大綱：
前言
學 Java 的朋友都知道，Java 是一門典型的面向?qū)ο蟮母呒壋绦蛟O計語言，但有些朋友可能不清楚面向?qū)ο笤?Java 中是怎么體現(xiàn)的。這篇文章就向大家分享下 Java 在面向?qū)ο蠓矫娴囊恍┲R。
Java 語言簡介
Java 語言特點
首先我們看下 Java 的語言特點，如圖所示。
Java 是純粹的面向?qū)ο笳Z言，它因統(tǒng)一的字節(jié)碼文件和差異化的 JDK 而具有平臺無關(guān)的特性。
Java 內(nèi)置豐富的類庫，使開發(fā)者效率大為提升。它支持 web，廣泛應用于各大互聯(lián)網(wǎng)企業(yè)的網(wǎng)站后臺，像阿里美團都在使用。
Java 的安全性也很出眾，通過沙箱安全模型保證其安全性，能夠有效防止代碼攻擊。
Java 也具備很強的健壯性，比如它是強類型的，支持自動化的垃圾回收器，有完善的異常處理機制和安全檢查機制。
與 C++ 比較
| 比較點 | C++ | Java |
|---|---|---|
| 語言類型 | 編譯型語言 | 解釋編譯混合型語言 |
| 執(zhí)行速度 | 快 | 慢 |
| 是否跨平臺 | 否 | 是 |
| 面向?qū)ο?/td> | 面向?qū)ο蠛兔嫦蜻^程混合 | 純面向?qū)ο?/td> |
| 指針 | 有 | 無 |
| 多繼承 | 支持 | 不支持 |
| 內(nèi)存管理 | 手動 | 自動 |
從語言類型上看，C++ 的代碼編譯好，就能被計算機直接執(zhí)行，它是編譯型語言，而 Java 經(jīng)過 javac 把 java 文件編譯成 class 文件后，還需要 JVM 從 class 文件讀一行解釋執(zhí)行一行，它是解釋編譯混合型語言。也就是中間多了 JVM 這一道，Java 也具備了跨平臺特性，而 C++ 就沒有這個優(yōu)勢。
從面向?qū)ο蟮慕嵌壬峡矗珻++ 是在 C 的基礎上的新的探索和延伸，因此它是面向?qū)ο蠛兔嫦蜻^程混合的，而 Java 就是純粹的面向?qū)ο蟆?/p>
此外，C++ 有指針的概念，Java 沒有。C++ 支持多繼承，Java 不支持。C++ 需要手動進行內(nèi)存管理，Java 通過垃圾回收機制實現(xiàn)了內(nèi)存的自動管理。
面向?qū)ο笏枷?/h2>
我們總在提面向?qū)ο螅敲嫦驅(qū)ο缶烤故莻€什么東西呢?在面向?qū)ο蟪霈F(xiàn)之前的面向過程又是怎么回事呢?
其實無論是面向?qū)ο筮€是面向過程，都是我們在編程時解決問題的一種思維方式。
只是在最初，人們分析解決問題的時候，會把所需要的步驟都列出來，然后通過計算機中的函數(shù)把這些步驟挨個實現(xiàn)，這種過程化的敘事思維，就是面向過程思想。
你比如，把一頭大象放進冰箱，通常會怎么做呢?
我們的習慣性思維是會分為三步，第一步，把冰箱門打開，第二步，把大象推進去，第三步，把冰箱門關(guān)閉(假設大象很乖，冰箱很大，門能關(guān)住)。
這種方式固然可行，但當場景發(fā)生變化時，比如大象變成豬，冰箱變成衣柜，類似的步驟用面向過程編碼的話就要再寫一遍。這樣就導致代碼開發(fā)變成了記流水賬，久而久之就成為面條代碼。
我們仔細分析面向過程的這些步驟，會發(fā)現(xiàn)都是命令式的動賓結(jié)構(gòu)：開冰箱門，推大象，場景切換下就是開衣柜門，推豬。你會發(fā)現(xiàn)從這兩種場景下是可以找到共性的，就是冰箱門和衣柜門都有打開和關(guān)閉的特點，大象和豬都能走路，所以能被人推進去。
當我們的視角不再是流程，而是操作對象的時候，冰箱門和衣柜門都可以抽象成門，有打開和關(guān)閉的特點，大象和豬都可以抽象成動物，有走路的特點。按這個思路，我們可以把這件事簡化成主謂結(jié)構(gòu)：門打開，動物走進去，門關(guān)閉。
這種把事情分解成各個對象，描述對象在整個事情中的行為，就是面向?qū)ο笏枷搿?/p>
你會發(fā)現(xiàn)，面向過程更講事情的步驟，面向?qū)ο蟾v對象的行為。
面向?qū)ο罂梢曰趯ο蟮墓残宰龀橄螅瑸檐浖こ痰膹陀煤蛿U展打好了堅實的基礎。這也是為什么在很多大型軟件開發(fā)選型上，大多會使用面向?qū)ο笳Z言編程。
面向?qū)ο蠡A
Java 作為純面向?qū)ο笳Z言，我們有必要了解下面向?qū)ο蟮幕A知識。
面向?qū)ο笥兴拇筇卣鳎浅橄螅庋b，繼承和多態(tài)。也有很多人認為是三大特征，不包括抽象，但我覺得抽象才是面向?qū)ο笏枷胱顬楹诵牡奶卣鳎渌齻€特征無非是抽象這個特征的實現(xiàn)或擴展。
我總結(jié)了下這四大特征在面向?qū)ο箢I域分別解決了什么問題，再逐一介紹：
- 抽象：解決了模型的定義問題。
- 封裝：解決了數(shù)據(jù)的安全問題。
- 繼承：解決了代碼的重用問題。
- 多態(tài)：解決了程序的擴展問題。
抽象
抽象是面向?qū)ο蟮暮诵奶卣鳎己玫臉I(yè)務抽象和建模分析能力是后續(xù)封裝、繼承和多態(tài)的基礎。
面向?qū)ο笏季S中的抽象分為歸納和演繹兩種。
歸納是從具體到本質(zhì)，從個性到共性，將一類對象的共同特征進行歸一化的邏輯思維過程。比如我們把見到的像大象，老虎，豬這些能動的有生命的對象，歸納成動物。
演繹是從本質(zhì)到具體，從共性到個性，將對象逐步形象化的過程。比如從生物到動物，從動物到鳥類。演繹的結(jié)果不一定是具體的對象，也可以是像鳥類這種抽象結(jié)果，因此演繹仍然是抽象思維，而非具象思維。
Java 中的 Object 類是任何類的默認父類，是對萬物的抽象。這就是我們常說的：萬物皆對象。
看一看 java.lang.Object 類的源碼，我們基本能看到 Java 世界里對象的共同特征。
getClass() 說明了對象是誰，toString() 是對象的名片，clone() 是繁殖對象的方式， finalize() 是銷毀對象的方式，hashCode() 和 equals() 是判斷當前對象與其他對象是否相等的方式，wait() 和 notify() 是對象間通信與協(xié)作的方式。
類的定義
除了 JDK 中提供的類之外，我們也可以基于自己業(yè)務場景的抽象定義類。
我們看下 Java 語法中的 class(類)是怎么構(gòu)成的。
以下是概覽圖，我們按圖介紹。
我們先關(guān)注圖中的黃色區(qū)塊，在 Java 里就叫 class(類)。
好比一個事物有屬性和能力一樣，比如人有名字，人能吃飯。對應到 Java class 里就是變量和方法，即紅色區(qū)塊和紫色區(qū)塊。
變量分為成員變量，靜態(tài)變量和局部變量三種，方法分為構(gòu)造方法、實例方法和靜態(tài)方法三種。
我們舉個例子來說明下，假設全世界的面包數(shù)量就 100 個，并且生產(chǎn)已經(jīng)停滯，而且只有蝸牛和小白兩個人能吃到，我們就可以按以下的代碼來描述這兩個人吃面包的過程以及面包的情況。
- package cn.java4u.oo;
- /**
- * @author 蝸牛
- * @from 公眾號：蝸牛互聯(lián)網(wǎng)
- */
- public class Person {
- /**
- * [成員變量]需要被實例化后使用，每個實例都有獨立空間，通過 對象.成員變量名 訪問
- * 名字
- */
- String name;
- /**
- * [靜態(tài)變量]用 static 修飾，無需實例化即可使用，每個實例共享同一個空間，通過 類名.靜態(tài)變量名 訪問
- * 面包數(shù)量
- */
- static int breadNum;
- /**
- * [方法]
- * 吃一個面包
- *
- * @param num 方法入?yún)ⅲ悦姘膫€數(shù)
- */
- void eatBread(int num) {
- // num 是[局部變量]
- breadNum = breadNum - num;
- System.out.println(name + "吃了 " + num + " 個面包，全世界的面包還剩 " + breadNum + " 個！");
- }
- /**
- * [構(gòu)造方法]
- * 參數(shù)為空
- */
- public Person() {
- }
- /**
- * [構(gòu)造方法]
- *
- * @param name 此為構(gòu)造方法的輸入?yún)?shù)，和成員變量有關(guān)
- */
- public Person(String name) {
- this.name = name;
- }
- /**
- * [靜態(tài)方法]
- */
- static void testStaticMethod() {
- // 通過構(gòu)造方法，初始化名字叫蝸牛的人
- Person woniu = new Person("蝸牛");
- // 通過構(gòu)造方法，初始化名字叫小白的人
- Person xiaobai = new Person("小白");
- // 假設全世界的面包數(shù)量就 100 個，并且生產(chǎn)已經(jīng)停滯
- Person.breadNum = 100;
- // 蝸牛吃五個面包
- woniu.eatBread(5);
- // 小白吃六個面包
- xiaobai.eatBread(6);
- // 打印成員變量和靜態(tài)變量的值
- System.out.println(woniu.name + "和" + xiaobai.name + "吃飽后，世界只剩 " + Person.breadNum + " 個面包了！");
- }
- }
變量
首先定義了一個名字叫 Person 的類，表示人，然后定義了一個成員變量 name ，表示人的名字。成員變量也叫實例變量，實例變量的特點就是，每個實例都有獨立的變量，各個實例之間的同名變量互不影響。
其次定義了一個靜態(tài)變量 breadNum ，表示面包的數(shù)量，靜態(tài)變量用 static 修飾。靜態(tài)變量相對于成員變量就不一樣了，它是共享的，所有實例會共享這個變量。
方法
再接著定義了一個返回值為空，只有一個入?yún)⒌姆椒?eatBread(int num) ，方法入?yún)?num 作為局部變量參與了內(nèi)部的運算，通過和它的運算，靜態(tài)變量breadNum 的值得到了更新，并打印了一行操作信息。方法的語法結(jié)構(gòu)如下：
- 修飾符 返回類型 方法名(方法參數(shù)列表) {
- 方法語句;
- return 方法返回值;
- }
另外定義了 Person 的構(gòu)造方法，你會發(fā)現(xiàn)構(gòu)造方法和實例方法的區(qū)別就在于它是沒有返回值的，因為它的目的很純粹，就是用來初始化對象實例的，和 new 搭配使用，所以它的方法名就是類名，它的入?yún)⒁捕己统蓡T變量有關(guān)。
到這里，你會發(fā)現(xiàn) Java 方法的返回值并不是那么重要，甚至沒有都可以!是的，Java 方法簽名只包括名稱和參數(shù)列表，它們是 JVM 標識方法的唯一索引，是不包含返回值的，更不包括各種修飾符或者異常類型。
請注意，任何 class 都是有構(gòu)造方法的，即便你代碼里不寫，Java 也會在編譯 class 文件的時候，默認生成一個無參構(gòu)造方法。但是只要你手動定義了構(gòu)造方法，編譯器就不會再生成。也就是說如果你僅定義了一個有參的構(gòu)造方法，那么編譯后的 class 是不會有無參構(gòu)造方法的。
最后就是靜態(tài)方法了，名字叫testStaticMethod ，方法內(nèi)部我們先用 new 的語法調(diào)用構(gòu)造方法，初始化了蝸牛和小白的Person 對象。這兩個對象就是 Person 這個類的實例，這兩個實例都有獨立空間，name 這個成員變量也只能在被實例化后使用，可以通過 對象.成員變量名 訪問。
接著我們通過 Person.breadNum 也就是 類名.靜態(tài)變量名 的方式，更新了面包數(shù)量這個值。你會發(fā)現(xiàn) breadNum 這個靜態(tài)變量無需實例化就能使用，因為就這個變量而言，Person 的每個實例都會共享同一個空間。這意味著，每個實例的修改，都會影響到這個變量值的變化。
然后我們通過調(diào)用方法 eatBread 并傳參的方式，影響到了面包數(shù)的值。
- package cn.java4u.oo;
- /**
- * @author 蝸牛
- * @from 公眾號：蝸牛互聯(lián)網(wǎng)
- */
- public class MainTest {
- public static void main(String[] args) {
- // 靜態(tài)方法，通過 類名.靜態(tài)方法名 訪問
- Person.testStaticMethod();
- }
- }
最后我們新定義一個觸發(fā)調(diào)用的入口函數(shù)，通過 Person.testStaticMethod() 這樣 類名.靜態(tài)方法名 的方式就能訪問到靜態(tài)方法了。
抽象類與接口
抽象類顧名思義，就是會對同類事物做抽象，通常包括抽象方法、實例方法和成員變量。被抽象類和抽象類之間是 is-a 關(guān)系，這種關(guān)系要符合里氏替換原則，即抽象類的所有行為都適用于被抽象類，比如大象是一種動物，動物能做的事，大象都能做。代碼定義也很簡單，就是在 class 和抽象方法上加 abstract 修飾符。
- package cn.java4u.oo;
- /**
- * 抽象類
- *
- * @author 蝸牛
- * @from 公眾號：蝸牛互聯(lián)網(wǎng)
- */
- public abstract class AbstractClass {
- String name;
- /**
- * 實例方法
- *
- * @return name
- */
- public String getName() {
- return name;
- }
- /**
- * 抽象方法-操作
- *
- * @return 結(jié)果
- */
- public abstract String operate();
- }
如果一個抽象類只有一個抽象方法，那它就等于一個接口。接口是要求被普通類實現(xiàn)的，接口在被實現(xiàn)時體現(xiàn)的是 can-do 關(guān)系，它表達了對象具備的能力。鳥有飛的能力，宇宙飛船也有飛的能力，那么可以把飛的能力抽出來，有單獨的一個抽象方法。代碼定義也比較簡單，class 的關(guān)鍵字用 interface 來替換。
- package cn.java4u.oo;
- /**
- * 可飛翔
- *
- * @author 蝸牛
- * @from 公眾號：蝸牛互聯(lián)網(wǎng)
- */
- public interface Flyable {
- /**
- * 飛
- */
- void fly();
- }
內(nèi)部類
在 Java 源代碼文件中，只能定義一個類目與文件名完全一致的公開類。如果想在一個文件里定義另外一個類，在面向?qū)ο罄镆彩侵С值模蔷褪莾?nèi)部類。
內(nèi)部類分為以下四種：
- 靜態(tài)內(nèi)部類：static class StaticInnerClass {}
- 成員內(nèi)部類：private class InstanceInnerClass {}
- 局部內(nèi)部類：class MethodClass {} ，定義在方法或者表達式內(nèi)部
- 匿名內(nèi)部類：(new Thread() {}).start();
示例代碼如下：
- package cn.java4u.oo.innerclass;
- /**
- * 內(nèi)部類演示
- *
- * @author 蝸牛
- * @from 公眾號：蝸牛互聯(lián)網(wǎng)
- */
- public class InnerClassDemo {
- /**
- * 成員內(nèi)部類
- */
- private class InstanceInnerClass {}
- /**
- * 靜態(tài)內(nèi)部類
- */
- static class StaticInnerClass {}
- public static void main(String[] args) {
- // 兩個匿名內(nèi)部類
- (new Thread() {}).start();
- (new Thread() {}).start();
- // 方法內(nèi)部類
- class MethodClass {}
- }
- }
編譯后得到的 class 文件如下：
我們會發(fā)現(xiàn)，無論什么類型的內(nèi)部類，都會編譯生成一個獨立的 .class 文件，只是內(nèi)部類文件的命名會通過 $ 連接在外部類后面，如果是匿名內(nèi)部類，會使用編號來標識。
類關(guān)系
關(guān)系是指事物之間有沒有單向或者相互作用或者影響的狀態(tài)。
類和類之間的關(guān)系分為 6 種：
- 繼承：extends(is-a)
- 實現(xiàn)：implements(can-do)
- 組合：類是成員變量(contains-a)
- 聚合：類是成員變量(has-a)
- 依賴：單向弱關(guān)系(使用類屬性，類方法、作為方法入?yún)ⅰ⒆鳛榉椒ǔ鰠?
- 關(guān)聯(lián)：互相平等的依賴關(guān)系(links-a)
序列化
內(nèi)存中的數(shù)據(jù)對象只有轉(zhuǎn)換為二進制流才可以進行數(shù)據(jù)持久化和網(wǎng)絡傳輸。
將數(shù)據(jù)對象轉(zhuǎn)換成二進制流的過程稱為對象的序列化(Serialization)。
將二進制流恢復為數(shù)據(jù)對象的過程稱為反序列化(Deserialization)。
常見的序列化使用場景是 RPC 框架的數(shù)據(jù)傳輸。
常見的序列化方式有三種：
- Java 原生序列化。特點是兼容性好，不支持跨語言，性能一般。
- Hessian 序列化。特點是支持跨語言，性能高效。
- JSON 序列化。特點是可讀性好，但有安全風險。
封裝
封裝是在抽象基礎上決定信息是否公開，以及公開等級，核心問題是以什么樣的方式暴露哪些信息。
抽象是要找到成員和行為的共性，成員是行為的基本生產(chǎn)資料，具有一定的敏感性，不能直接對外暴露。封裝的主要任務是對成員、數(shù)據(jù)、部分內(nèi)部敏感行為實現(xiàn)隱藏。
對成員的訪問與修改必須通過定義公共的接口來進行，另外某些敏感方法或者外部不需要感知的復雜邏輯處理，一般也會進行封裝。
像智能音箱，與用戶交互的唯一接口就是語音輸入，封裝了內(nèi)部的實現(xiàn)細節(jié)和相關(guān)數(shù)據(jù)。
設計模式七大原則之一的迪米特法則也說明了封裝的要求，A 接口使用 B 接口，對 B 知道的要盡可能少。
包
包(package)這個名稱就很明顯體現(xiàn)了封裝的含義，它能起到把一個模塊封裝到一起，并由幾個接口開放給使用方。使用方只能看到接口信息，而看不到接口實現(xiàn)。另外包解決重名問題，相同類名在相同路徑下是不允許的，切換包路徑就可以起相同的類名。
訪問權(quán)限控制
我們編寫的程序要想讓使用方，能看到一些信息，又不能看到另外一些信息，這就涉及到信息隱藏了。
信息隱藏是面向?qū)ο蟪绦蛟O計的重要特點之一，它可以防止類的使用者意外損壞數(shù)據(jù)，對任何實現(xiàn)細節(jié)所作的修改不會影響到使用該類的其它代碼，也使類更易于使用。
那在 Java 里，實現(xiàn)信息隱藏的就是訪問權(quán)限控制機制了。Java 的訪問權(quán)限控制有 4 個訪問修飾符：public 、protected 、private 和缺省。可以使用這四個訪問修飾符修飾類的成員，它們在不同位置的可訪問性如下表所示。
| 位置\訪問修飾符 | public | protected | 缺省 | private |
|---|---|---|---|---|
| 本類 | 可以 | 可以 | 可以 | 可以 |
| 本包 | 可以 | 可以 | 可以 | 不可以 |
| 子類 | 可以 | 可以 | 不可以 | 不可以 |
| 所有 | 可以 | 不可以 | 不可以 | 不可以 |
你會發(fā)現(xiàn) public 不受任何限制，本類和非本類都可以隨意訪問(全局友好)。protected 本類及其子類可以訪問(父子友好)，同一個包中的其它類也可以訪問(包內(nèi)友好)。而缺省的時候，只有相同包中的類可以訪問(包內(nèi)友好)。private 只有本類可以訪問，其余都不可以(類內(nèi)友好)。
除了為類成員添加訪問權(quán)限控制外，也可以在定義類的時候，為類添加訪問修飾符，對類進行訪問權(quán)限控制。不過對類使用的訪問修飾符只有 public 和缺省兩種，訪問范圍也分別是全局友好和包內(nèi)友好。
getter 與 setter
為了讓類成員不對外直接暴露，我們經(jīng)常把成員變量的訪問權(quán)限設置成 private，而成員值的訪問與修改使用相應的 getter/setter 方法。而不是對 public 的成員進行讀取和修改。
- package cn.java4u.oo.packagedemo;
- /**
- * getter 和 setter 演示
- * @author 蝸牛
- * @from 公眾號：蝸牛互聯(lián)網(wǎng)
- */
- public class GetterSetterDemo {
- /**
- * 成員變量私有化
- */
- private String name;
- /**
- * 公開方法獲取成員變量值
- *
- * @return 名稱
- */
- public String getName() {
- return name;
- }
- /**
- * 公開方法設置成員變量值
- *
- * @param name 名稱
- */
- public void setName(String name) {
- this.name = name;
- }
- }
繼承
類繼承
class 了解之后，我們考慮一個問題。如果兩個 class，它們的變量和方法基本相同，僅僅是其中一個 class 會有一些自己特有的變量和方法，那么相同的那些變量和方法真的需要在兩個 class 里都寫一遍么?
比如一個表示學生的 class Student ，它相對于 class Person 只是多了一個分數(shù) score 的成員變量，那還需要像下面這樣，把 name 字段也定義一下么?
- /**
- * 學生
- *
- * @author 蝸牛
- * @from 公眾號：蝸牛互聯(lián)網(wǎng)
- */
- public class Student {
- /**
- * 名字
- */
- String name;
- /**
- * 分數(shù)
- */
- int score;
- }
這很明顯帶來了代碼重復使用的問題!那能不能在 Student 中不寫重復代碼?
Java 里的繼承這時候就派上用場了，繼承是面向?qū)ο缶幊痰囊环N強大機制，能夠讓子類繼承父類的特征和行為，使得子類對象能夠具有父類的實例變量和方法。
子類繼承父類，父類派生子類。父類也叫基類，子類也叫派生類。
通常來講，類的層次劃分總是下一層比上一層更具體，并且包含上一層的特征，這樣下層的類就能自動享有上層類的特點和性質(zhì)。繼承就是派生類自動地共享基類中成員變量和成員方法的機制。
在 Java 中，通過 extends 關(guān)鍵字實現(xiàn)繼承，并且所有的類都是繼承于 java.lang.Object ，所以這就是萬物皆對象在 Java 里的真實寫照。你可能會疑惑，自定義的類并沒有 extends 關(guān)鍵字為什么還能繼承 Object 呢?這是因為這個類在 java.lang 包里，Java 已經(jīng)默認支持了。
- package cn.java4u.oo;
- /**
- * 學生
- *
- * @author 蝸牛
- * @from 公眾號：蝸牛互聯(lián)網(wǎng)
- */
- public class Student extends Person {
- /**
- * 分數(shù)
- */
- int score;
- }
知道了繼承的基礎概念后，我們看下繼承有啥作用?
首先，繼承是能夠自動傳播代碼和重用代碼的有力工具。它能在已有類上擴充新類，減少代碼的重復冗余，也因為冗余度降低，一致性就得到了增強，從而提升了程序的可維護性。
其次，繼承可以清晰體現(xiàn)出類與類之間的層次結(jié)構(gòu)關(guān)系，提升了代碼的可讀性。
另外，繼承是單方向的，即派生類可以繼承和訪問基類成員，但反過來就不行。而且 Java 只允許單一繼承，也就是一個派生類不能同時繼承多個基類，這和 C++ 是不同的。
在使用繼承的時候，還要考慮到基類成員的訪問控制權(quán)限。可以參考封裝那塊內(nèi)容的訪問權(quán)限控制介紹。
子類實例化過程
特別要說明的是，父類的構(gòu)造方法是不能被子類繼承的，即便它是 public 的。父類的構(gòu)造方法負責初始化屬于它的成員變量，而子類的構(gòu)造方法只需考慮自己特有的成員變量即可，不必關(guān)注父類狀況。
- package cn.java4u.oo.inherit;
- /**
- * 定義父類
- *
- * @author 蝸牛
- * @from 公眾號：蝸牛互聯(lián)網(wǎng)
- */
- public class Parent {
- /**
- * 構(gòu)造方法
- */
- public Parent() {
- System.out.println("這是父類 Parent 的構(gòu)造方法");
- }
- }
- package cn.java4u.oo.inherit;
- /**
- * 定義子類
- *
- * @author 蝸牛
- * @from 公眾號：蝸牛互聯(lián)網(wǎng)
- */
- public class Child extends Parent {
- /**
- * 構(gòu)造方法
- */
- public Child() {
- System.out.println("這是子類 Child 的構(gòu)造方法");
- }
- }
- package cn.java4u.test;
- import cn.java4u.oo.inherit.Child;
- /**
- * @author 蝸牛
- * @from 公眾號：蝸牛互聯(lián)網(wǎng)
- */
- public class InheritTest {
- public static void main(String[] args) {
- Child child = new Child();
- }
- }
因此，在實例化子類的對象時，Java 先是執(zhí)行父類的構(gòu)造方法，然后執(zhí)行子類的構(gòu)造方法。如果父類還有更上級的父類，就會先調(diào)用更高父類的構(gòu)造方法，再逐個依次地將所有繼承關(guān)系的父類構(gòu)造方法全部執(zhí)行。如果父類的構(gòu)造方法執(zhí)行失敗，則子類的對象也將無法實例化。
上邊的代碼運行后，會輸出：
- 這是父類 Parent 的構(gòu)造方法
- 這是子類 Child 的構(gòu)造方法
this 與 super
如果調(diào)用父類構(gòu)造方法涉及到有參構(gòu)造方法，可以使用 super 關(guān)鍵字來調(diào)用父類構(gòu)造方法并傳遞參數(shù)。
說的 super，它還有一個能力，就是父類和子類的成員如果同名了，子類中默認只能訪問自己的那個成員，想要訪問父類成員，就可以通過 super.成員名 的語法實現(xiàn)。但這有個前提，就是父類的這個成員不能是 private 的。
與 super 相對的關(guān)鍵字是 this ，super 是指向當前對象的父類，而 this 是指向當前對象自己。this 常用來區(qū)別成員變量和局部變量，比如下面這段代碼，我加了個有參構(gòu)造方法。
- public class Parent {
- int a;
- /**
- * 構(gòu)造方法
- */
- public Parent() {
- System.out.println("這是父類 Parent 的構(gòu)造方法");
- }
- public Parent(int a) {
- this.a = a;
- }
- }
多態(tài)
說完繼承，我們再來聊聊多態(tài)!
多態(tài)字面上解釋，就是程序可以有多個運行狀態(tài)。
既然是運行狀態(tài)，那其實更多的是強調(diào)方法的使用。
重載與覆寫
方法在兩種情況下使用會比較特別，一種是 overload(重載)，overload 方法是本類內(nèi)的新方法，方法名一樣，但是參數(shù)的類型或數(shù)量不同。這種方法沒有特殊的標識，通過類內(nèi)方法是否重名判定。
另外一種就是 override(覆寫)，override 方法是繼承關(guān)系下子類的新方法，方法簽名和父類完全相同。這種方法都會有 @Override 注解的標識。
- package cn.java4u.oo.polymorphism;
- /**
- * 動物
- *
- * @author 蝸牛
- * @from 公眾號：蝸牛互聯(lián)網(wǎng)
- */
- public class Animal {
- /**
- * 與 eat(String food) 重載
- */
- public void eat() {
- System.out.println("Animal.eat");
- }
- /**
- * 與 eat() 重載
- *
- * @param food 食物
- */
- public void eat(String food) {
- System.out.println("Animal.eat: " + food);
- }
- /**
- * 覆寫
- *
- * @return 字符串
- * @see java.lang.Object#toString
- */
- @Override
- public String toString() {
- return "Animal " + super.toString();
- }
- }
舉個例子，Animal 類里兩個 eat 方法就互為重載方法，toString 方法就是相對于父類方法 java.lang.Object#toString 的覆寫方法。
多態(tài)就發(fā)生在覆寫這種場景下。針對某個類型的方法調(diào)用，它真正執(zhí)行的方法取決于運行時期實際類型的方法。比如下面這段代碼，當聲明類型為 Object ,初始化類型為 Animal 時，你覺得輸出的是 Animal 的 toString 方法，還是 Object 的 toString 方法?
- package cn.java4u.oo.polymorphism;
- /**
- * @author 蝸牛
- * @from 公眾號：蝸牛互聯(lián)網(wǎng)
- */
- public class PolymorphismTest {
- /**
- * 打印對象
- *
- * @param scene 打印場景
- * @param obj obj
- */
- public static void printObjectString(String scene, Object obj) {
- System.out.println(scene + ": " + obj.toString());
- }
- public static void main(String[] args) {
- // 父類引用初始化父類對象并打印
- Object rootObj = new Object();
- printObjectString("父類引用初始化父類對象", rootObj);
- // 子類引用初始化子類對象并打印
- Animal animal = new Animal();
- printObjectString("子類引用初始化子類對象", animal);
- // 父類引用初始化子類對象并打印
- Object animalWhenParentRef = new Animal();
- printObjectString("父類引用初始化子類對象", animal);
- }
- }
答案是子類 Animal 的 toString 方法!
- 父類引用初始化父類對象: java.lang.Object@60e53b93
- 子類引用初始化子類對象: Animal cn.java4u.oo.polymorphism.Animal@5e2de80c
- 父類引用初始化子類對象: Animal cn.java4u.oo.polymorphism.Animal@5e2de80c
實際類型為 Animal 引用類型為 Object ，調(diào)用 toString 方法時，實際上是子類的。因此我們可以得出結(jié)論：Java 的實例方法調(diào)用是基于運行時的實際類型的動態(tài)調(diào)用，而非變量的聲明類型。這種特性就是多態(tài)!
你會發(fā)現(xiàn) printObjectString 方法的第二個參數(shù)，即便聲明的是 Object ，實際運行的時候，卻可以是它的子類覆寫方法。
至此，我們也理出了 Java 實現(xiàn)多態(tài)三要素，那就是 繼承、覆寫和向上轉(zhuǎn)型。即兩個類之間有繼承關(guān)系，某個類覆寫了父類的某個方法，方法的引用會指向子類的實現(xiàn)處。
總結(jié)
本文從 Java 的視角出發(fā)，分析了 Java 的語言特點，并和 C++ 進行了比較。針對這門典型的面向?qū)ο笳Z言，我們又分析了面向?qū)ο蟮母拍詈退枷搿＝又诿嫦驅(qū)ο蟮奶卣鳎撼橄蟆⒎庋b、繼承和多態(tài)，我們又詳細的分析了在 Java 中的體現(xiàn)方式，并伴有很多樣例代碼輔助學習。看完這篇文章，想必你對面向?qū)ο筮@個東西會有更全面的了解。
好啦，本期的分享就到這里，如果各位喜歡我的分享，請務必三連，點贊，在看，收藏，關(guān)注我，這會對我有非常大的幫助。
我們下期再見。
