Kotlin極簡教程：第7章 面向對象編程

原文鏈接：https://github.com/EasyKotlin

在前面的章節中，我們學習了Kotlin的語言基礎知識、類型系統、集合類以及泛型相關的知識。在本章節以及下一章中，我們將一起來學習Kotlin對面向對象編程以及函數式編程的支持。

7.1 面向對象編程思想

7.1.1 一切皆是映射

《易傳·繫辭上傳》：“易有太極，是生兩儀，兩儀生四象，四象生八卦。” 如今的互聯網世界，其基石卻是01（陰陽），不得不佩服我華夏先祖的博大精深的智慧。

一切皆是映射

計算機領域中的所有問題,都可以通過向上一層進行抽象封裝來解決.這裏的封裝的本質概念，其實就是“映射”。

就好比通過的電子電路中的電平進行01邏輯映射，於是有了布爾代數，數字邏輯電路系統；

對01邏輯的進一步封裝抽象成CPU指令集映射，誕生了彙編語言；

通過彙編語言的向上抽象一層編譯解釋器，於是有了pascal，fortran，C語言；

再對核心函數api進行封裝形成開發包（Development Kit), 於是有了Java，C++ 。

從面向過程到面向對象，再到設計模式，架構設計，面向服務，Sass/Pass/Iass等等的思想，各種軟件理論思想五花八門，但萬變不離其宗。

• 你要解決一個怎樣的問題？
• 你的問題領域是怎樣的？
• 你的模型（數據結構）是什麼？
• 你的算法是什麼？
• 你對這個世界的本質認知是怎樣的？
• 你的業務領域的邏輯問題，流程是什麼？

Grady Booch：我對OO編程的目標從來就不是複用。相反，對我來說，對象提供了一種處理複雜性的方式。這個問題可以追溯到亞里士多德：您把這個世界視爲過程還是對象？在OO興起運動之前，編程以過程爲中心–例如結構化設計方法。然而，系統已經到達了超越其處理能力的複雜性極點。有了對象，我們能夠通過提升抽象級別來構建更大的、更復雜的系統–我認爲，這纔是面向對象編程運動的真正勝利。

最初， 人們使用物理的或邏輯的二進制機器指令來編寫程序， 嘗試着表達思想中的邏輯， 控制硬件計算和顯示， 發現是可行的；

接着， 創造了助記符 —— 彙編語言， 比機器指令更容易記憶；

再接着， 創造了編譯器、解釋器和計算機高級語言， 能夠以人類友好自然的方式去編寫程序， 在犧牲少量性能的情況下， 獲得比彙編語言更強且更容易使用的語句控制能力：條件、分支、循環， 以及更多的語言特性： 指針、結構體、聯合體、枚舉等， 還創造了函數， 能夠將一系列指令封裝成一個獨立的邏輯塊反覆使用；

逐漸地，產生了面向過程的編程方法；

後來， 人們發現將數據和邏輯封裝成對象， 更接近於現實世界， 且更容易維護大型軟件， 又出現了面向對象的編程語言和編程方法學， 增加了新的語言特性： 繼承、 多態、 模板、 異常錯誤。

爲了不必重複開發常見工具和任務， 人們創造和封裝了容器及算法、SDK， 垃圾回收器， 甚至是併發庫；

爲了讓計算機語言更有力更有效率地表達各種現實邏輯， 消解軟件開發中遇到的衝突， 還在語言中支持了元編程、 高階函數， 閉包 等有用特性。

爲了更高效率地開發可靠的軟件和應用程序， 人們逐漸構建了代碼編輯器、 IDE、 代碼版本管理工具、公共庫、應用框架、 可複用組件、系統規範、網絡協議、 語言標準等， 針對遇到的問題提出了許多不同的思路和解決方案， 並總結提煉成特定的技術和設計模式， 還探討和形成了不少軟件開發過程， 用來保證最終發佈的軟件質量。 儘管編寫的這些軟件和工具還存在不少 BUG ，但是它們都“奇蹟般地存活”， 並共同構建了今天蔚爲壯觀的互聯網時代的電商，互聯網金融，雲計算，大數據，物聯網，機器智能等等的“虛擬世界”。

7.1.2 二進制01與易經陰陽

二進制數是用0和1兩個數碼來表示的數。它的基數爲2，進位規則是“逢二進一”，借位規則是“借一當二”，由18世紀德國數理哲學大師萊布尼茲發現。當前的計算機系統使用的基本上是二進制系統。

19世紀愛爾蘭邏輯學家B對邏輯命題的思考過程轉化爲對符號0，1的某種代數演算，二進制是逢2進位的進位制。0、1是基本算符。因爲它只使用0、1兩個數字符號，非常簡單方便，易於用電子方式實現。

二進制的發現直接導致了電子計算器和計算機的發明，並讓計算機得到了迅速的普及，進入各行各業，成爲人類生活和生產的重要工具。

二進制的實質是通過兩個數字“0”和“1”來描述事件。在人類的生產、生活等許多領域，我們可以通過計算機來虛擬地描述現實中存在的事件，並能通過給定的條件和參數模擬事件變化的規律。二進制的計算機幾乎是萬能的，能將我們生活的現實世界完美複製，並且還能根據我們人類給定的條件模擬在現實世界難以實現的各種實驗。

但是，不論計算機能給我們如何多變、如何完美、如何複雜的畫面，其本源只是簡單的“0”和“1”。“0”和“1”在計算機中通過不同的組合與再組合，模擬出一個紛繁複雜、包羅萬象的虛擬世界。我們簡單圖示如下：

二進制的“0”和“1”通過計算機裏能夠創造出一個虛擬的、紛繁的世界。自然界中的陰陽形成了現實世界的萬事萬物。

所以自然世界的“陰”“陽”作爲基礎切實地造就了複雜的現實世界，計算機的“0”和“1”形象地模擬現實世界的一切現象，易學中的“卦”和“陰陽爻”抽象地揭示了自然界存在的事件和其變化規律。

所以說，編程的本質跟大自然創造萬物的本質是一樣的。

7.1.3 從面向過程到面向對象

從IBM公司的約翰·巴庫斯在1957年開發出世界上第一個高級程序設計語言Fortran至今，高級程序設計語言的發展已經經歷了整整半個世紀。在這期間，程序設計語言主要經歷了從面向過程（如C和Pascal語言）到面向對象（如C++和Java語言），再到面向組件編程（如.NET平臺下的C#語言），以及面向服務架構技術（如SOA、Service以及最近很火的微服務架構）等。

面向過程編程

結構化編程思想的核心：功能分解（自頂向下，逐層細化）。

1971年4月份的 Communications of ACM上，尼古拉斯·沃斯（Niklaus Wirth，1934年2月15日—, 結構化編程思想的創始人。因發明了Euler、Alogo-W、Modula和Pascal等一系列優秀的編程語言並提出了結構化編程思想而在1984年獲得了圖靈獎。）發表了論文“通過逐步求精方式開發程序’（Program Development by Stepwise Refinement），首次提出“結構化程序設計”（structure programming）的概念。

不要求一步就編製成可執行的程序，而是分若干步進行，逐步求精。

第一步編出的程序抽象度最高，第二步編出的程序抽象度有所降低…… 最後一步編出的程序即爲可執行的程序。

用這種方法編程，似乎複雜，實際上優點很多，可使程序易讀、易寫、易調試、易維護、易保證其正確性及驗證其正確性。

結構化程序設計方法又稱爲“自頂向下”或“逐步求精”法，在程序設計領域引發了一場革命，成爲程序開發的一個標準方法，尤其是在後來發展起來的軟件工程中獲得廣泛應用。有人評價說Wirth的結構化程序設計概念“完全改變了人們對程序設計的思維方式”，這是一點也不誇張的。

尼古拉斯· 沃思教授在編程界提出了一個著名的公式：

程序 = 數據結構 + 算法

面向對象編程

面向對象編程思想的核心：應對變化，提高複用。

阿倫·凱（Alan Kay）：面向對象編程思想的創始人。2003年因在面向對象編程上所做的巨大貢獻而獲得圖靈獎。

The best way to predict the future is to invent it，預測未來最好的方法是創造它！（Alan Kay）

阿倫·凱是Smalltalk面向對象編程語言的發明人之一，也是面向對象編程思想的創始人之一，同時，他還是筆記本電腦最早的構想者和現代Windows GUI的建築師。最早提出PC概念和互聯網的也是阿倫·凱，所以人們都尊稱他爲“預言大師”。他是當今IT界屈指可數的技術天才級人物。

面向對象編程思想主要是複用性和靈活性（彈性）。複用性是面向對象編程的一個主要機制。靈活性主要是應對變化的特性，因爲客戶的需求是不斷改變的，怎樣適應客戶需求的變化，這是軟件設計靈活性或者說是彈性的問題。

Java是一種面向對象編程語言，它基於Smalltalk語言，作爲OOP語言，它具有以下五個基本特性：

1. 萬物皆對象，每一個對象都會存儲數據，並且可以對自身執行操作。因此，每一個對象包含兩部分：成員變量和成員方法。在成員方法中可以改變成員變量的值。
2. 程序是對象的集合，他們通過發送消息來告知彼此所要做的事情，也就是調用相應的成員函數。
3. 每一個對象都有自己的由其他對象所構成的存儲，也就是說在創建新對象的時候可以在成員變量中使用已存在的對象。
4. 每個對象都擁有其類型，每個對象都是某個類的一個實例，每一個類區別於其它類的特性就是可以向它發送什麼類型的消息，也就是它定義了哪些成員函數。
5. 某一個特定類型的所有對象都可以接受同樣的消息。另一種對對象的描述爲：對象具有狀態(數據，成員變量)、行爲(操作，成員方法)和標識(成員名，內存地址)。

面嚮對象語言其實是對現實生活中的實物的抽象。

每個對象能夠接受的請求(消息)由對象的接口所定義，而在程序中必須由滿足這些請求的代碼，這段代碼稱之爲這個接口的實現。當向某個對象發送消息(請求)時，這個對象便知道該消息的目的(該方法的實現已定義)，然後執行相應的代碼。

我們經常說一些代碼片段是優雅的或美觀的，實際上意味着它們更容易被人類有限的思維所處理。

對於程序的複合而言，好的代碼是它的表面積要比體積增長的慢。

代碼塊的“表面積”是是我們複合代碼塊時所需要的信息（接口API協議定義）。代碼塊的“體積”就是接口內部的實現邏輯（API背後的實現代碼）。

在面向對象編程中，一個理想的對象應該是隻暴露它的抽象接口（純表面， 無體積），其方法則扮演箭頭的角色。如果爲了理解一個對象如何與其他對象進行復合，當你發現不得不深入挖掘對象的實現之時，此時你所用的編程範式的原本優勢就蕩然無存了。

面向組件和麪向服務

• 面向組件

我們知道面向對象支持重用，但是重用的單元很小，一般是類；而面向組件則不同，它可以重用多個類甚至一個程序。也就是說面向組件支持更大範圍內的重用，開發效率更高。如果把面向對象比作重用零件，那麼面向組件則是重用部件。

• 面向服務

將系統進行功能化，每個功能提供一種服務。現在非常流行微服務MicroService技術以及SOA（面向服務架構）技術。

面向過程（Procedure）→面向對象（Object）→ 面向組件（Component） →面向服務（Service）

正如解決數學問題通常我們會談“思想”，諸如反證法、化繁爲簡等，解決計算機問題也有很多非常出色的思想。思想之所以稱爲思想，是因爲“思想”有拓展性與引導性，可以解決一系列問題。

解決問題的複雜程度直接取決於抽象的種類及質量。過將結構、性質不同的底層實現進行封裝，向上提供統一的API接口，讓使用者覺得就是在使用一個統一的資源，或者讓使用者覺得自己在使用一個本來底層不直接提供、“虛擬”出來的資源。

計算機中的所有問題 , 都可以通過向上抽象封裝一層來解決。同樣的,任何複雜的問題, 最終總能夠迴歸最本質,最簡單。

面向對象編程是一種自頂向下的程序設計方法。萬事萬物都是對象,對象有其行爲(方法),狀態(成員變量,屬性)。OOP是一種編程思想，而不是針對某個語言而言的。當然，語言影響思維方式，思維依賴語言的表達，這也是辯證的來看。

所謂“面嚮對象語言”，其實經典的“過程式語言”（比如Pascal，C），也能體現面向對象的思想。所謂“類”和“對象”，就是C語言裏面的抽象數據類型結構體（struct）。

而面向對象的多態是唯一相比struct多付出的代價，也是最重要的特性。這就是SmallTalk、Java這樣的面嚮對象語言所提供的特性。

回到一個古老的話題：程序是什麼？

在面向對象的編程世界裏，下面的這個公式

程序 = 算法 + 數據結構

可以簡單重構成：

程序 = 基於對象操作的算法 + 以對象爲最小單位的數據結構

封裝總是爲了減少操作粒度，數據結構上的封裝導致了數據的減少，自然減少了問題求解的複雜度；對代碼的封裝使得代碼得以複用，減少了代碼的體積，同樣使問題簡化。這個時候，算法操作的就是一個抽象概念的集合。

在面向對象的程序設計中，我們便少不了集合類容器。容器就用來存放一類有共同抽象概念的東西。這裏說有共同概念的東西（而沒有說對象），其實，就是我們上一個章節中講到的泛型。這樣對於一個通用的算法，我們就可以最大化的實現複用，作用於的集合。

面向對象的本質就是讓對象有多態性，把不同對象以同一特性來歸組，統一處理。至於所謂繼承、虛表、等等概念，只是其實現的細節。

在遵循這些面向對象設計原則基礎上，前輩們總結出一些解決不同問題場景的設計模式，以GOF的23中設計模式最爲知名。

我們用一幅圖簡單概括一下面向對象編程的知識框架：

講了這麼多思考性的思想層面的東西，我們下面來開始Kotlin的面向對象編程的學習。Kotlin對面向對象編程是完全支持的。

7.2 類與構造函數

Kotlin和Java很相似，也是一種面向對象的語言。下面我們來一起學習Kotlin的面向對象的特性。如果您熟悉Java或者C++、C#中的類，您可以很快上手。同時，您也將看到Kotlin與Java中的面向對象編程的一些不同的特性。

Kotlin中的類和接口跟Java中對應的概念有些不同，比如接口可以包含屬性聲明；Kotlin的類聲明，默認是final和public的。

另外，嵌套類並不是默認在內部的。它們不包含外部類的隱式引用。

在構造函數方面，Kotlin簡短的主構造函數在大多數情況下都可以滿足使用，當然如果有稍微複雜的初始化邏輯，我們也可以聲明次級構造函數來完成。

我們還可以使用 data 修飾符來聲明一個數據類，使用 object 關鍵字來表示單例對象、伴生對象等。

Kotlin類的成員可以包含：

• 構造函數和初始化塊
• 屬性
• 函數
• 嵌套類和內部類
• 對象聲明

7.2.1 聲明類

和大部分語言類似，Kotlin使用class作爲類的關鍵字，當我們聲明一個類時，直接通過class加類名的方式來實現：

class World

這樣我們就聲明瞭一個World類。

7.2.2 構造函數

在 Kotlin 中，一個類可以有

• 一個主構造函數（primary constructor）
• 一個或多個次構造函數（secondary constructor）

主構造函數

主構造函數是類頭的一部分，直接放在類名後面：

open class Student constructor(var name: String, var age: Int) : Any() {
...
}

如果主構造函數沒有任何註解或者可見性修飾符，可以省略這個 constructor 關鍵字。如果構造函數有註解或可見性修飾符，這個 constructor 關鍵字是必需的，並且這些修飾符在它前面：

annotation class MyAutowired

class ElementaryStudent public @MyAutowired constructor(name: String, age: Int) : Student(name, age) {
...
}

與普通屬性一樣，主構造函數中聲明的屬性可以是可變的（var）或只讀的（val）。

主構造函數不能包含任何的代碼。初始化的代碼可以放到以 init 關鍵字作爲前綴的初始化塊（initializer blocks）中：

open class Student constructor(var name: String, var age: Int) : Any() {

    init {
        println("Student{name=$name, age=$age} created!")
    }
   ...

}

主構造的參數可以在初始化塊中使用,也可以在類體內聲明的屬性初始化器中使用。

次構造函數

在類體中，我們也可以聲明前綴有 constructor 的次構造函數，次構造函數不能有聲明 val 或 var ：

class MiddleSchoolStudent {
    constructor(name: String, age: Int) {
    }
}

如果類有一個主構造函數，那麼每個次構造函數需要委託給主構造函數， 委託到同一個類的另一個構造函數用 this 關鍵字即可：

class ElementarySchoolStudent public @MyAutowired constructor(name: String, age: Int) : Student(name, age) {
    override var weight: Float = 80.0f

    constructor(name: String, age: Int, weight: Float) : this(name, age) {
        this.weight = weight
    }

    ...
}

如果一個非抽象類沒有聲明任何（主或次）構造函數，它會有一個生成的不帶參數的主構造函數。構造函數的可見性是 public。

私有主構造函數

我們如果希望這個構造函數是私有的，我們可以如下聲明：

class DontCreateMe private constructor() {
}

這樣我們在代碼中，就無法直接使用主構造函數來實例化這個類，下面的寫法是不允許的：

val dontCreateMe = DontCreateMe() // cannot access it

但是，我們可以通過次構造函數引用這個私有主構造函數來實例化對象：

7.2.2 類的屬性

我們再給這個World類加入兩個屬性。我們可能直接簡單地寫成：

class World1 {
    val yin: Int
    val yang: Int
}

在Kotlin中，直接這樣寫語法上是會報錯的：

意思很明顯，是說這個類的屬性必須要初始化，或者如果不初始化那就得是抽象的abstract屬性。

我們把這兩個屬性都給初始化如下：

class World1 {
    val yin: Int = 0
    val yang: Int = 1
}

我們再來使用測試代碼來看下訪問這兩個屬性的方式：

>>> class World1 {
...     val yin: Int = 0
...     val yang: Int = 1
... }
>>> val w1 = World1()
>>> w1.yin
0
>>> w1.yang
1

上面的World1類的代碼，在Java中等價的寫法是：

public final class World1 {
   private final int yin;
   private final int yang = 1;

   public final int getYin() {
      return this.yin;
   }

   public final int getYang() {
      return this.yang;
   }
}

我們可以看出，Kotlin中的類的字段自動帶有getter方法和setter方法。而且寫起來比Java要簡潔的多。

7.2.3 函數（方法）

我們再來給這個World1類中加上一個函數：

class World2 {
    val yin: Int = 0
    val yang: Int = 1

    fun plus(): Int {
        return yin + yang
    }
}

val w2 = World2()
println(w2.plus()) // 輸出 1

7.3 抽象類

7.3.1 抽象類的定義

含有抽象函數的類(這樣的類需要使用abstract修飾符來聲明)，稱爲抽象類。

下面是一個抽象類的例子：

abstract class Person(var name: String, var age: Int) : Any() {

    abstract var addr: String
    abstract val weight: Float

    abstract fun doEat()
    abstract fun doWalk()

    fun doSwim() {
        println("I am Swimming ... ")
    }

    open fun doSleep() {
        println("I am Sleeping ... ")
    }
}

7.3.2 抽象函數

在上面的這個抽象類中，不僅可以有抽象函數abstract fun doEat() abstract fun doWalk()，同時可以有具體實現的函數fun doSwim()， 這個函數默認是final的。也就是說，我們不能重寫這個doSwim函數：

如果一個函數想要設計成能被重寫，例如fun doSleep(),我們給它加上open關鍵字即可。然後，我們就可以在子類中重寫這個open fun doSleep():

class Teacher(name: String, age: Int) : Person(name, age) {
    override var addr: String = "HangZhou"
    override val weight: Float = 100.0f

    override fun doEat() {
        println("Teacher is Eating ... ")
    }

    override fun doWalk() {
        println("Teacher is Walking ... ")
    }

    override fun doSleep() {
        super.doSleep()
        println("Teacher is Sleeping ... ")
    }

//    override fun doSwim() { // cannot be overriden
//        println("Teacher is Swimming ... ")
//    }
}

抽象函數是一種特殊的函數：它只有聲明，而沒有具體的實現。抽象函數的聲明格式爲：

abstract fun doEat()

關於抽象函數的特徵，我們簡單總結如下：

• 抽象函數必須用abstract關鍵字進行修飾
• 抽象函數不用手動添加open，默認被open修飾
• 抽象函數沒有具體的實現
• 含有抽象函數的類成爲抽象類，必須由abtract關鍵字修飾。抽象類中可以有具體實現的函數，這樣的函數默認是final（不能被覆蓋重寫），如果想要重寫這個函數，給這個函數加上open關鍵字。

7.3.3 抽象屬性

抽象屬性就是在var或val前被abstract修飾，抽象屬性的聲明格式爲：

abstract var addr : String
abstract val weight : Float

關於抽象屬性，需要注意的是：

1. 抽象屬相在抽象類中不能被初始化
2. 如果在子類中沒有主構造函數，要對抽象屬性手動初始化。如果子類中有主構造函數，抽象屬性可以在主構造函數中聲明。

綜上所述，抽象類和普通類的區別有：

1.抽象函數必須爲public或者protected（因爲如果爲private，則不能被子類繼承，子類便無法實現該方法），缺省情況下默認爲public。

也就是說，這三個函數

abstract fun doEat()
abstract fun doWalk()

fun doSwim() {
    println("I am Swimming ... ")
}

默認的都是public的。

另外抽象類中的具體實現的函數，默認是final的。上面的三個函數，等價的Java的代碼如下：

public abstract void doEat();

public abstract void doWalk();

public final void doSwim() {
   String var1 = "I am Swimming ... ";
   System.out.println(var1);
}

2.抽象類不能用來創建對象實例。也就是說，下面的寫法編譯器是不允許的：

3.如果一個類繼承於一個抽象類，則子類必須實現父類的抽象方法。實現父類抽象函數，我們使用override關鍵字來表明是重寫函數：

class Programmer(override var addr: String, override val weight: Float, name: String, age: Int) : Person(name, age) {
    override fun doEat() {
        println("Programmer is Eating ... ")
    }

    override fun doWalk() {
        println("Programmer is Walking ... ")
    }
}

如果子類沒有實現父類的抽象函數，則必須將子類也定義爲爲abstract類。例如：

abstract class Writer(override var addr: String, override val weight: Float, name: String, age: Int) : Person(name, age) {
    override fun doEat() {
        println("Programmer is Eating ... ")
    }

    abstract override fun doWalk();
}

doWalk函數沒有實現父類的抽象函數，那麼我們在子類中把它依然定義爲抽象函數。相應地這個子類，也成爲了抽象子類，需要使用abstract關鍵字來聲明。

如果抽象類中含有抽象屬性，在實現子類中必須將抽象屬性初始化，除非子類也爲抽象類。例如我們聲明一個Teacher類繼承Person類：

class Teacher(name: String, age: Int) : Person(name, age) {
    override var addr: String //  error， 需要初始化，或者聲明爲abstract
    override val weight: Float //  error， 需要初始化，或者聲明爲abstract
    ...
}

這樣寫，編譯器會直接報錯：

解決方法是，在實現的子類中，我們將抽象屬性初始化即可：

class Teacher(name: String, age: Int) : Person(name, age) {
    override var addr: String = "HangZhou"
    override val weight: Float = 100.0f

    override fun doEat() {
        println("Teacher is Eating ... ")
    }

    override fun doWalk() {
        println("Teacher is Walking ... ")
    }
}

7.4 接口

7.4.1 接口定義

和Java類似，Kotlin使用interface作爲接口的關鍵詞：

interface ProjectService

Kotlin 的接口與 Java 8 的接口類似。與抽象類相比，他們都可以包含抽象的方法以及方法的實現:

interface ProjectService {
    val name: String
    val owner: String
    fun save(project: Project)
    fun print() {
        println("I am project")
    }
}

7.4.2 實現接口

接口是沒有構造函數的。我們使用冒號: 語法來實現一個接口，如果有多個用，逗號隔開：

class ProjectServiceImpl : ProjectService
class ProjectMilestoneServiceImpl : ProjectService, MilestoneService

我們也可以實現多個接口：

class Project

class Milestone

interface ProjectService {
    val name: String
    val owner: String
    fun save(project: Project)
    fun print() {
        println("I am project")
    }
}

interface MilestoneService {
    val name: String
    fun save(milestone: Milestone)
    fun print() {
        println("I am Milestone")
    }
}

class ProjectMilestoneServiceImpl : ProjectService, MilestoneService {
    override val name: String
        get() = "ProjectMilestone"
    override val owner: String
        get() = "Jack"

    override fun save(project: Project) {
        println("Save Project")
    }

    override fun print() {
//        super.print()
        super<ProjectService>.print()
        super<MilestoneService>.print()
    }

    override fun save(milestone: Milestone) {
        println("Save Milestone")
    }
}

當子類繼承了某個類之後，便可以使用父類中的成員變量，但是並不是完全繼承父類的所有成員變量。具體的原則如下：

1.能夠繼承父類的public和protected成員變量；不能夠繼承父類的private成員變量；

2.對於父類的包訪問權限成員變量，如果子類和父類在同一個包下，則子類能夠繼承；否則，子類不能夠繼承；

3.對於子類可以繼承的父類成員變量，如果在子類中出現了同名稱的成員變量，則會發生隱藏現象，即子類的成員變量會屏蔽掉父類的同名成員變量。如果要在子類中訪問父類中同名成員變量，需要使用super關鍵字來進行引用。

7.4.3 覆蓋衝突

在kotlin中， 實現繼承通常遵循如下規則：如果一個類從它的直接父類繼承了同一個函數的多個實現，那麼它必須重寫這個函數並且提供自己的實現(或許只是直接用了繼承來的實現) 爲表示使用父類中提供的方法我們用 super 表示。

在重寫print()時，因爲我們實現的ProjectService、MilestoneService都有一個print()函數，當我們直接使用super.print()時，編譯器是無法知道我們想要調用的是那個裏面的print函數的，這個我們叫做覆蓋衝突：

這個時候，我們可以使用下面的語法來調用：

super<ProjectService>.print()
super<MilestoneService>.print()

7.4.4 接口中的屬性

在接口中聲明的屬性，可以是抽象的，或者是提供訪問器的實現。

在企業應用中，大多數的類型都是無狀態的，如：Controller、ApplicationService、DomainService、Repository等。

因爲接口沒有狀態， 所以它的屬性是無狀態的。

interface MilestoneService {
    val name: String // 抽象的
    val owner: String get() = "Jack" // 訪問器

    fun save(milestone: Milestone)
    fun print() {
        println("I am Milestone")
    }
}

class MilestoneServiceImpl : MilestoneService {
    override val name: String
        get() = "MilestoneServiceImpl name"


    override fun save(milestone: Milestone) {
        println("save Milestone")
    }
}

7.5 抽象類和接口的差異

概念上的區別

接口主要是對動作的抽象，定義了行爲特性的規約。
抽象類是對根源的抽象。當你關注一個事物的本質的時候，用抽象類；當你關注一個操作的時候，用接口。

語法層面上的區別

接口不能保存狀態，可以有屬性但必須是抽象的。
一個類只能繼承一個抽象類，而一個類卻可以實現多個接口。

類如果要實現一個接口，它必須要實現接口聲明的所有方法。但是，類可以不實現抽象類聲明的所有方法，當然，在這種情況下，類也必須得聲明成是抽象的。

接口中所有的方法隱含的都是抽象的。而抽象類則可以同時包含抽象和非抽象的方法。

設計層面上的區別

抽象類是對一種事物的抽象，即對類抽象，而接口是對行爲的抽象。抽象類是對整個類整體進行抽象，包括屬性、行爲，但是接口卻是對類局部（行爲）進行抽象。

繼承是 is a的關係，而 接口實現則是 has a 的關係。如果一個類繼承了某個抽象類，則子類必定是抽象類的種類，而接口實現就不需要有這層類型關係。

設計層面不同，抽象類作爲很多子類的父類，它是一種模板式設計。而接口是一種行爲規範，它是一種輻射式設計。也就是說：

• 對於抽象類，如果需要添加新的方法，可以直接在抽象類中添加具體的實現，子類可以不進行變更；

• 而對於接口則不行，如果接口進行了變更，則所有實現這個接口的類都必須進行相應的改動。

實際應用上的差異

在實際使用中，使用抽象類(也就是繼承)，是一種強耦合的設計，用來描述A is a B 的關係，即如果說A繼承於B，那麼在代碼中將A當做B去使用應該完全沒有問題。比如在Android中，各種控件都可以被當做View去處理。

如果在你設計中有兩個類型的關係並不是is a，而是is like a，那就必須慎重考慮繼承。因爲一旦我們使用了繼承，就要小心處理好子類跟父類的耦合依賴關係。組合優於繼承。

7.6 繼承

繼承是面向對象編程的一個重要的方式，因爲通過繼承，子類就可以擴展父類的功能。

在Kotlin中，所有的類會默認繼承Any這個父類，但Any並不完全等同於java中的Object類，因爲它只有equals(),hashCode()和toString()這三個方法。

7.6.1 open類

除了抽象類、接口默認可以被繼承（實現）外，我們也可以把一個類聲明爲open的，這樣我們就可以繼承這個open類。

當我們想定義一個父類時，需要使用open關鍵字:

open class Base{ 
} 

當然，抽象類是默認open的。

然後在子類中使用冒號：進行繼承

class SubClass : Base(){ 
} 

如果父類有構造函數，那麼必須在子類的主構造函數中進行繼承，沒有的話則可以選擇主構造函數或二級構造函數

//父類 
open class Base(type:String){ 

} 

//子類 
class SubClass(type:String) : Base(type){ 

} 

Kotlin中的override重寫和java中也有所不同，因爲Kotlin提倡所有的操作都是明確的，因此需要將希望被重寫的函數設爲open:

open fun doSomething() {} 

然後通過override標記實現重寫

override fun doSomething() { 
 super.doSomething() 
 } 

同樣的，抽象函數以及接口中定義的函數默認都是open的。

override重寫的函數也是open的，如果希望它不被重寫，可以在前面增加final :

open class SubClass : Base{ 
    constructor(type:String) : super(type){ 
    } 

    final override fun doSomething() { 
        super.doSomething() 
    } 
} 

7.6.2 多重繼承

有些編程語言支持一個類擁有多個父類，例如C++。 我們將這個特性稱之爲多重繼承（multiple inheritance）。多重繼承會有二義性和鑽石型繼承樹（DOD：Diamond Of Death）的複雜性問題。Kotlin跟Java一樣，沒有采用多繼承，任何一個子類僅允許一個父類存在，而在多繼承的問題場景下，使用實現多個interface 組合的方式來實現多繼承的功能。

代碼示例：

package com.easy.kotlin

abstract class Animal {
    fun doEat() {
        println("Animal Eating")
    }
}

abstract class Plant {
    fun doEat() {
        println("Plant Eating")
    }
}

interface Runnable {
    fun doRun()
}

interface Flyable {
    fun doFly()
}

class Dog : Animal(), Runnable {
    override fun doRun() {
        println("Dog Running")
    }
}

class Eagle : Animal(), Flyable {
    override fun doFly() {
        println("Eagle Flying")
    }
}

// 始祖鳥, 能飛也能跑
class Archaeopteryx : Animal(), Runnable, Flyable {
    override fun doRun() {
        println("Archaeopteryx Running")
    }

    override fun doFly() {
        println("Archaeopteryx Flying")
    }

}

fun main(args: Array<String>) {
    val d = Dog()
    d.doEat()
    d.doRun()

    val e = Eagle()
    e.doEat()
    e.doFly()

    val a = Archaeopteryx()
    a.doEat()
    a.doFly()
    a.doRun()
}

上述代碼類之間的關係，我們用圖示如下：

我們可以看出，Archaeopteryx繼承了Animal類，用了父類doEat()函數功能；實現了Runnable接口，擁有了doRun()函數規範；實現了Flyable接口，擁有了doFly()函數規範。

在這裏，我們通過實現多個接口，組合完成了的多個功能，而不是設計多個層次的複雜的繼承關係。

7.7 枚舉類

Kotlin的枚舉類定義如下：

public abstract class Enum<E : Enum<E>>(name: String, ordinal: Int): Comparable<E> {
    companion object {}

    public final val name: String
    public final val ordinal: Int

    public override final fun compareTo(other: E): Int
    protected final fun clone(): Any

    public override final fun equals(other: Any?): Boolean
    public override final fun hashCode(): Int
    public override fun toString(): String
}

我們可以看出，這個枚舉類有兩個屬性：

public final val name: String
public final val ordinal: Int

分別表示的是枚舉對象的值跟下標位置。

同時，我們可以看出枚舉類還實現了Comparable接口。

7.7.1 枚舉類基本用法

枚舉類的最基本的用法是實現類型安全的枚舉：

enum class Direction {
    NORTH, SOUTH, WEST, EAST
}

>>> val north = Direction.NORTH
>>> north.name
NORTH
>>> north.ordinal
0
>>> north is Direction
true

每個枚舉常量都是一個對象。枚舉常量用逗號分隔。

7.7.2 初始化枚舉值

我們可以如下初始化枚舉類的值：

enum class Color(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF)
}

>>> val red = Color.RED
>>> red.rgb
16711680

另外，枚舉常量也可以聲明自己的匿名類:

enum class ActivtyLifeState {
    onCreate {
        override fun signal() = onStart
    },

    onStart {
        override fun signal() = onStop
    },

    onStop {
        override fun signal() = onStart
    },

    onDestroy {
        override fun signal() = onDestroy
    };

    abstract fun signal(): ActivtyLifeState
}

>>> val s = ActivtyLifeState.onCreate
>>> println(s.signal())
onStart

7.7.3 使用枚舉常量

我們使用enumValues()函數來列出枚舉的所有值：

@SinceKotlin("1.1")
public inline fun <reified T : Enum<T>> enumValues(): Array<T>

每個枚舉常量，默認都name名稱和ordinal位置的屬性(這個跟Java的Enum類裏面的類似)：

val name: String
val ordinal: Int

代碼示例：

enum class RGB { RED, GREEN, BLUE }

>>> val rgbs = enumValues<RGB>().joinToString { "${it.name} : ${it.ordinal} " }
>>> rgbs
RED : 0 , GREEN : 1 , BLUE : 2 

我們直接聲明瞭一個簡單枚舉類，我們使用遍歷函數enumValues<RGB>()列出了RGB枚舉類的所有枚舉值。使用it.name it.ordinal直接訪問各個枚舉值的名稱和位置。

另外，我們也可以自定義枚舉屬性值：

enum class Color(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF)
}

>>> val colors = enumValues<Color>().joinToString { "${it.rgb} : ${it.name} : ${it.ordinal} " }
>>> colors
16711680 : RED : 0 , 65280 : GREEN : 1 , 255 : BLUE : 2 

然後，我們可以直接使用it.rgb訪問屬性名來得到對應的屬性值。

7.8 註解類

Kotlin 的註解與 Java 的註解完全兼容。

7.8.1 聲明註解

annotation class 註解名

代碼示例：

@Target(AnnotationTarget.CLASS,
        AnnotationTarget.FUNCTION,
        AnnotationTarget.EXPRESSION,
        AnnotationTarget.FIELD,
        AnnotationTarget.LOCAL_VARIABLE,
        AnnotationTarget.TYPE,
        AnnotationTarget.TYPEALIAS,
        AnnotationTarget.TYPE_PARAMETER,
        AnnotationTarget.VALUE_PARAMETER)
@Retention(AnnotationRetention.SOURCE)
@MustBeDocumented
@Repeatable
annotation class MagicClass

@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.SOURCE)
@MustBeDocumented
@Repeatable
annotation class MagicFunction

@Target(AnnotationTarget.CONSTRUCTOR)
@Retention(AnnotationRetention.SOURCE)
@MustBeDocumented
@Repeatable
annotation class MagicConstructor

在上面的代碼中，我們通過向註解類添加元註解(meta-annotation)的方法來指定其他屬性：

• @Target ：指定這個註解可被用於哪些元素(類, 函數, 屬性, 表達式, 等等.);
• @Retention ：指定這個註解的信息是否被保存到編譯後的 class 文件中, 以及在運行時是否可以通過反
  射訪問到它；
• @Repeatable：允許在單個元素上多次使用同一個註解；
• @MustBeDocumented ： 表示這個註解是公開 API 的一部分, 在自動產生的 API 文檔的類或者函數簽名中, 應該包含這個註解的信息。

這幾個註解定義在kotlin/annotation/Annotations.kt類中。

7.8.2 使用註解

註解可以用在類、函數、參數、變量（成員變量、局部變量）、表達式、類型上等。這個由該註解的元註解@Target定義。

@MagicClass class Foo @MagicConstructor constructor() {

    constructor(index: Int) : this() {
        this.index = index
    }

    @MagicClass var index: Int = 0
    @MagicFunction fun magic(@MagicClass name: String) {

    }
}

註解在主構造器上，主構造器必須加上關鍵字 “constructor”

@MagicClass class Foo @MagicConstructor constructor() {
...
}

7.9 單例模式(Singleton)與伴生對象(companion object)

7.9.1 單例模式(Singleton)

單例模式很常用。它是一種常用的軟件設計模式。例如，Spring中的Bean默認就是單例。通過單例模式可以保證系統中一個類只有一個實例。即一個類只有一個對象實例。

我們用Java實現一個簡單的單例類的代碼如下：

class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

測試代碼：

Singleton singleton1 = Singleton.getInstance();

可以看出，我們先在單例類中聲明瞭一個私有靜態的Singleton instance變量，然後聲明一個私有構造函數private Singleton() {}, 這個私有構造函數使得外部無法直接通過new的方式來構建對象：

Singleton singleton2 = new Singleton(); //error, cannot private access

最後提供一個public的獲取當前類的唯一實例的靜態方法getInstance()。我們這裏給出的是一個簡單的單例類，是線程不安全的。

7.9.2 object對象

Kotlin中沒有 靜態屬性和方法，但是也提供了實現類似於單例的功能，我們可以使用關鍵字 object 聲明一個object對象:

object AdminUser {
    val username: String = "admin"
    val password: String = "admin"
    fun getTimestamp() = SimpleDateFormat("yyyyMMddHHmmss").format(Date())
    fun md5Password() = EncoderByMd5(password + getTimestamp())
}

測試代碼：

val adminUser = AdminUser.username
val adminPassword = AdminUser.md5Password()
println(adminUser)  // admin
println(adminPassword)  // g+0yLfaPVYxUf6TMIdXFXw==，這個值具體運行時會變化

爲了方便在REPL中演示說明，我們再寫一個示例代碼：

>>> object User {
...     val username: String = "admin"
...     val password: String = "admin"
... }

object對象只能通過對象名字來訪問：

>>> User.username
admin
>>> User.password
admin

不能像下面這樣使用構造函數：

>>> val u = User()
error: expression 'User' of type 'Line130.User' cannot be invoked as a function. The function 'invoke()' is not found
val u = User()
        ^

爲了更加直觀的瞭解object對象的概念，我們把上面的object User的代碼反編譯成Java代碼：

public final class User {
   @NotNull
   private static final String username = "admin";
   @NotNull
   private static final String password = "admin";
   public static final User INSTANCE;

   @NotNull
   public final String getUsername() {
      return username;
   }

   @NotNull
   public final String getPassword() {
      return password;
   }

   private User() {
      INSTANCE = (User)this;
      username = "admin";
      password = "admin";
   }

   static {
      new User();
   }
}

從上面的反編譯代碼，我們可以直觀瞭解Kotlin的object背後的一些原理。

7.9.3 嵌套（Nested）object對象

這個object對象還可以放到一個類裏面：

class DataProcessor {
    fun process() {
        println("Process Data")
    }

    object FileUtils {
        val userHome = "/Users/jack/"

        fun getFileContent(file: String): String {
            var content = ""
            val f = File(file)
            f.forEachLine { content = content + it + "\n" }
            return content
        }
    }
}

測試代碼：

DataProcessor.FileUtils.userHome // /Users/jack/
DataProcessor.FileUtils.getFileContent("test.data") // 輸出文件的內容

同樣的，我們只能通過類的名稱來直接訪問object，不能使用對象實例引用。下面的寫法是錯誤的：

val dp = DataProcessor()
dp.FileUtils.userHome // error, Nested object FileUtils cannot access object via reference

我們在Java中通常會寫一些Utils類，這樣的類我們在Kotlin中就可以直接使用object對象：

object HttpUtils {
    val client = OkHttpClient()

    @Throws(Exception::class)
    fun getSync(url: String): String? {
        val request = Request.Builder()
                .url(url)
                .build()

        val response = client.newCall(request).execute()
        if (!response.isSuccessful()) throw IOException("Unexpected code " + response)

        val responseHeaders = response.headers()
        for (i in 0..responseHeaders.size() - 1) {
            println(responseHeaders.name(i) + ": " + responseHeaders.value(i))
        }
        return response.body()?.string()
    }

    @Throws(Exception::class)
    fun getAsync(url: String) {
        var result: String? = ""

        val request = Request.Builder()
                .url(url)
                .build()
        client.newCall(request).enqueue(object : Callback {
            override fun onFailure(call: Call, e: IOException?) {
                e?.printStackTrace()
            }

            @Throws(IOException::class)
            override fun onResponse(call: Call, response: Response) {
                if (!response.isSuccessful()) throw IOException("Unexpected code " + response)

                val responseHeaders = response.headers()
                for (i in 0..responseHeaders.size() - 1) {
                    println(responseHeaders.name(i) + ": " + responseHeaders.value(i))
                }
                result = response.body()?.string()
                println(result)
            }
        })
    }
}

測試代碼：

val url = "http://www.baidu.com"
val html1 = HttpUtils.getSync(url) // 同步get
println("html1=${html1}") 
HttpUtils.getAsync(url) // 異步get

7.9.4 匿名object

還有，在代碼行內，有時候我們需要的僅僅是一個簡單的對象，我們這個時候就可以使用下面的匿名object的方式：

fun distance(x: Double, y: Double): Double {
    val porigin = object {
        var x = 0.0
        var y = 0.0
    }
    return Math.sqrt((x - porigin.x) * (x - porigin.x) + (y - porigin.y) * (y - porigin.y))
}

測試代碼：

distance(3.0, 4.0)

需要注意的是，匿名對象只可以用在本地和私有作用域中聲明的類型。代碼示例：

class AnonymousObjectType {
    // 私有函數，返回的是匿名object類型
    private fun privateFoo() = object {
        val x: String = "x"
    }

    // 公有函數，返回的類型是 Any
    fun publicFoo() = object {
        val x: String = "x" // 無法訪問到
    }

    fun test() {
        val x1 = privateFoo().x   // Works
        //val x2 = publicFoo().x  // ERROR: Unresolved reference 'x'
    }
}

fun main(args: Array<String>) {
    AnonymousObjectType().publicFoo().x // Unresolved reference 'x'
}

跟 Java 匿名內部類類似，object對象表達式中的代碼可以訪問來自包含它的作用域的變量（與 Java 不同的是，這不限於 final 變量）:

fun countCompare() {
    var list = mutableListOf(1, 4, 3, 7, 11, 9, 10, 20)
    var countCompare = 0
    Collections.sort(list, object : Comparator<Int> {
        override fun compare(o1: Int, o2: Int): Int {
            countCompare++
            println("countCompare=$countCompare")
            println(list)
            return o1.compareTo(o2)
        }
    })
}

測試代碼：

countCompare()

countCompare=1
[1, 4, 3, 7, 11, 9, 10, 20]
...
countCompare=17
[1, 3, 4, 7, 9, 10, 11, 20]

7.9.5 伴生對象(companion object)

Kotlin中還提供了 伴生對象 ，用companion object關鍵字聲明:

class DataProcessor {
    fun process() {
        println("Process Data")
    }

    object FileUtils {
        val userHome = "/Users/jack/"

        fun getFileContent(file: String): String {
            var content = ""
            val f = File(file)
            f.forEachLine { content = content + it + "\n" }
            return content
        }
    }

    companion object StringUtils {
        fun isEmpty(s: String): Boolean {
            return s.isEmpty()
        }
    }
}

一個類只能有1個伴生對象。也就是是下面的寫法是錯誤的：

class ClassA {
    companion object Factory {
        fun create(): ClassA = ClassA()
    }

    companion object Factory2 { // error, only 1 companion object is allowed per class
        fun create(): MyClass = MyClass()
    }
}

一個類的伴生對象默認引用名是Companion:

class ClassB {
    companion object {
        fun create(): ClassB = ClassB()
        fun get() = "Hi, I am CompanyB"
    }
}

我們可以直接像在Java靜態類中使用靜態方法一樣使用一個類的伴生對象的函數，屬性(但是在運行時，它們依舊是實體的實例成員)：

ClassB.Companion.index
ClassB.Companion.create()
ClassB.Companion.get()

其中， Companion可以省略不寫：

ClassB.index
ClassB.create()
ClassB.get()

當然，我們也可以指定伴生對象的名稱：

class ClassC {
    var index = 0
    fun get(index: Int): Int {
        return 0
    }

    companion object CompanyC {
        fun create(): ClassC = ClassC()
        fun get() = "Hi, I am CompanyC"
    }
}

測試代碼：

ClassC.index
ClassC.create()// com.easy.kotli.ClassC@7440e464，具體運行值會變化
ClassC.get() // Hi, I am CompanyC
ClassC.CompanyC.index
ClassC.CompanyC.create()
ClassC.CompanyC.get()

伴生對象的初始化是在相應的類被加載解析時，與 Java 靜態初始化器的語義相匹配。

即使伴生對象的成員看起來像其他語言的靜態成員，在運行時他們仍然是真實對象的實例成員。而且，還可以實現接口：

interface BeanFactory<T> {
    fun create(): T
}

class MyClass {
    companion object : BeanFactory<MyClass> {
        override fun create(): MyClass {
            println("MyClass Created!")
            return MyClass()
        }
    }
}

測試代碼：

MyClass.create()  // "MyClass Created!"
MyClass.Companion.create() // "MyClass Created!"

另外，如果想使用Java中的靜態成員和靜態方法的話，我們可以用：

@JvmField註解：生成與該屬性相同的靜態字段
@JvmStatic註解：在單例對象和伴生對象中生成對應的靜態方法

7.10 sealed 密封類

7.10.1 爲什麼使用密封類

就像我們爲什麼要用enum類型一樣，比如你有一個enum類型 MoneyUnit，定義了元、角、分這些單位。枚舉就是爲了控制住你所有要的情況是正確的，而不是用硬編碼方式寫成字符串“元”，“角”，“分”。

同樣，sealed的目的類似，一個類之所以設計成sealed，就是爲了限制類的繼承結構，將一個值限制在有限集中的類型中，而不能有任何其他的類型。

在某種意義上，sealed類是枚舉類的擴展：枚舉類型的值集合也是受限的，但每個枚舉常量只存在一個實例，而密封類的一個子類可以有可包含狀態的多個實例。

7.10.1 聲明密封類

要聲明一個密封類，需要在類名前面添加 sealed 修飾符。密封類的所有子類都必須與密封類在同一個文件中聲明（在 Kotlin 1.1 之前， 該規則更加嚴格：子類必須嵌套在密封類聲明的內部）：

sealed class Expression

class Unit : Expression()
data class Const(val number: Double) : Expression()
data class Sum(val e1: Expression, val e2: Expression) : Expression()
data class Multiply(val e1: Expression, val e2: Expression) : Expression()
object NaN : Expression()

使用密封類的主要場景是在使用 when 表達式的時候，能夠驗證語句覆蓋了所有情況，而無需再添加一個 else 子句：

fun eval(expr: Expression): Double = when (expr) {
    is Unit -> 1.0
    is Const -> expr.number
    is Sum -> eval(expr.e1) + eval(expr.e2)
    is Multiply -> eval(expr.e1) * eval(expr.e2)
    NaN -> Double.NaN
    // 不再需要 `else` 子句，因爲我們已經覆蓋了所有的情況
}

測試代碼：

fun main(args: Array<String>) {
    val u = eval(Unit())
    val a = eval(Const(1.1))
    val b = eval(Sum(Const(1.0), Const(9.0)))
    val c = eval(Multiply(Const(10.0), Const(10.0)))
    println(u)
    println(a)
    println(b)
    println(c)
}

輸出：

1.0
1.1
10.0
100.0

7.11 data 數據類

7.11.1 構造函數中的 val/var

在開始講數據類之前，我們先來看一下幾種類聲明的寫法。

寫法一：

class Aook(name: String)

這樣寫，這個name變量是無法被外部訪問到的。它對應的反編譯之後的Java代碼如下：

public final class Aook {
   public Aook(@NotNull String name) {
      Intrinsics.checkParameterIsNotNull(name, "name");
      super();
   }
}

寫法二：
要想這個name變量被訪問到，我們可以在類體中再聲明一個變量，然後把這個構造函數中的參數賦值給它：

class Cook(name: String) {
    val name = name
}

測試代碼：

val cook = Cook("Cook")
cook.name

對應的Java實現代碼是：

public final class Cook {
   @NotNull
   private final String name;

   @NotNull
   public final String getName() {
      return this.name;
   }

   public Cook(@NotNull String name) {
      Intrinsics.checkParameterIsNotNull(name, "name");
      super();
      this.name = name;
   }
}

寫法三：

class Dook(val name: String)
class Eook(var name: String)

構造函數中帶var、val修飾的變量，Kotlin編譯器會自動爲它們生成getter、setter函數。

上面的寫法對應的Java代碼就是：

public final class Dook {
   @NotNull
   private final String name;

   @NotNull
   public final String getName() {
      return this.name;
   }

   public Dook(@NotNull String name) {
      Intrinsics.checkParameterIsNotNull(name, "name");
      super();
      this.name = name;
   }
}

public final class Eook {
   @NotNull
   private String name;

   @NotNull
   public final String getName() {
      return this.name;
   }

   public final void setName(@NotNull String var1) {
      Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
      this.name = var1;
   }

   public Eook(@NotNull String name) {
      Intrinsics.checkParameterIsNotNull(name, "name");
      super();
      this.name = name;
   }
}

測試代碼：

val dook = Dook("Dook")
dook.name
val eook = Eook("Eook")
eook.name

下面我們來學習一下Kotlin中的數據類： data class 。

7.11.2 領域實體類

我們寫Java代碼的時候，會經常創建一些只保存數據的類。比如說：

• POJO類：POJO全稱是Plain Ordinary Java Object / Pure Old Java Object，中文可以翻譯成：普通Java類，具有一部分getter/setter方法的那種類就可以稱作POJO。

• DTO類：Data Transfer Object，數據傳輸對象類，泛指用於展示層與服務層之間的數據傳輸對象。

• VO類：VO有兩種說法,一個是ViewObject,一個是ValueObject。

• PO類：Persisent Object，持久對象。它們是由一組屬性和屬性的get和set方法組成。PO是在持久層所使用，用來封裝原始數據。

• BO類：Business Object，業務對象層，表示應用程序領域內“事物”的所有實體類。

• DO類：Domain Object，領域對象，就是從現實世界中抽象出來的有形或無形的業務實體。

等等。

這些我們統稱爲領域模型中的實體類。最簡單的實體類是POJO類，含有屬性及屬性對應的set和get方法，實體類常見的方法還有用於輸出自身數據的toString方法。

7.11.3 數據類data class的概念

在 Kotlin 中，也有對應這樣的領域實體類的概念，並在語言層面上做了支持，叫做數據類 ：

data class Book(val name: String)
data class Fook(var name: String)
data class User(val name: String, val gender: String, val age: Int) {
    fun validate(): Boolean {
        return true
    }
}

這裏的var/val是必須要帶上的。因爲編譯器要把主構造函數中聲明的所有屬性，自動生成以下函數：

equals()/hashCode() 
toString() : 格式是 User(name=Jacky, gender=Male, age=10)
componentN() 函數 : 按聲明順序對應於所有屬性component1()、component2() ...
copy() 函數

如果我們自定義了這些函數，或者繼承父類重寫了這些函數，編譯器就不會再去生成。

測試代碼：

val book = Book("Book")
book.name
book.copy("Book2")

val jack = User("Jack", "Male", 1)
jack.name
jack.gender
jack.age
jack.toString()
jack.validate()

val olderJack = jack.copy(age = 2)
val anotherJack = jack.copy(name = "Jacky", age = 10)

在一些場景下，我們需要複製一個對象來改變它的部分屬性，而其餘部分保持不變。 copy() 函數就是爲此而生成。例如上面的的 User 類的copy函數的使用：

val olderJack = jack.copy(age = 2)
val anotherJack = jack.copy(name = "Jacky", age = 10)

7.11.4 數據類的限制

數據類有以下的限制要求：

1.主構造函數需要至少有一個參數。下面的寫法是錯誤的：

data class Gook // error, data class must have at least one primary constructor parameter

2.主構造函數的所有參數需要標記爲 val 或 var；

data class Hook(name: String)// error, data class must have only var/val property

跟普通類一樣，數據類也可以有次級構造函數：

data class LoginUser(val name: String = "", val password: String = "") : DBase(), IBaseA, IBaseB {

    var isActive = true

    constructor(name: String, password: String, isActive: Boolean) : this(name, password) {
        this.isActive = isActive
    }
    ...
}

3.數據類不能是抽象、開放、密封或者內部的。也就是說，下面的寫法都是錯誤的：

abstract data class Iook(val name: String) // modifier abstract is incompatible with data
open data class Jook(val name: String) // modifier abstract is incompatible with data
sealed data class Kook(val name: String)// modifier sealed is incompatible with data
inner data class Look(val name: String)// modifier inner is incompatible with data

數據類只能是final的：

final data class Mook(val name: String) // modifier abstract is incompatible with data

4.在1.1之前數據類只能實現接口。自 1.1 起，數據類可以擴展其他類。代碼示例：

open class DBase
interface IBaseA
interface IBaseB

data class LoginUser(val name: String, val password: String) : DBase(), IBaseA, IBaseB {

    override fun equals(other: Any?): Boolean {
        return super.equals(other)
    }

    override fun hashCode(): Int {
        return super.hashCode()
    }

    override fun toString(): String {
        return super.toString()
    }

    fun validate(): Boolean {
        return true
    }
}

測試代碼：

val loginUser1 = LoginUser("Admin", "admin")
println(loginUser1.component1())
println(loginUser1.component2())
println(loginUser1.name)
println(loginUser1.password)
println(loginUser1.toString())

輸出：

Admin
admin
Admin
admin
com.easy.kotlin.LoginUser@7440e464

可以看出，由於我們重寫了override fun toString(): String, 對應的輸出使我們熟悉的類的輸出格式。

如果我們不重寫這個toString函數，則會默認輸出：

LoginUser(name=Admin, password=admin)

上面的類聲明的構造函數，要求我們每次必須初始化name、password的值，如果我們想擁有一個無參的構造函數，我們只要對所有的屬性指定默認值即可：

data class LoginUser(val name: String = "", val password: String = "") : DBase(), IBaseA, IBaseB {
...
}

這樣我們在創建對象的時候，就可以直接使用：

val loginUser3 = LoginUser()
loginUser3.name
loginUser3.password

7.11.5 數據類的解構

解構相當於 Component 函數的逆向映射：

val helen = User("Helen", "Female", 15)
val (name, gender, age) = helen
println("$name, $gender, $age years of age")

輸出：Helen, Female, 15 years of age

7.11.6 標準數據類Pair 和Triple

標準庫中的二元組 Pair類就是一個數據類：

public data class Pair<out A, out B>(
        public val first: A,
        public val second: B) : Serializable {
    public override fun toString(): String = "($first, $second)"
}

Kotlin標準庫中，對Pair類還增加了轉換成List的擴展函數：

public fun <T> Pair<T, T>.toList(): List<T> = listOf(first, second)

還有三元組Triple類：

public data class Triple<out A, out B, out C>(
        public val first: A,
        public val second: B,
        public val third: C) : Serializable {
    public override fun toString(): String = "($first, $second, $third)"
}
 fun <T> Triple<T, T, T>.toList(): List<T> = listOf(first, second, third)

7.12 嵌套類（Nested Class）

7.12.1 嵌套類：類中的類

類可以嵌套在其他類中，可以嵌套多層：

class NestedClassesDemo {
    class Outer {
        private val zero: Int = 0
        val one: Int = 1

        class Nested {
            fun getTwo() = 2
            class Nested1 {
                val three = 3
                fun getFour() = 4
            }
        }
    }
}

測試代碼：

val one = NestedClassesDemo.Outer().one
val two = NestedClassesDemo.Outer.Nested().getTwo()
val three = NestedClassesDemo.Outer.Nested.Nested1().three
val four = NestedClassesDemo.Outer.Nested.Nested1().getFour()
println(one)
println(two)
println(three)
println(four)

我們可以看出，訪問嵌套類的方式是直接使用 類名.， 有多少層嵌套，就用多少層類名來訪問。

普通的嵌套類，沒有持有外部類的引用，所以是無法訪問外部類的變量的：

class NestedClassesDemo {
class Outer {
        private val zero: Int = 0
        val one: Int = 1

        class Nested {
            fun getTwo() = 2

            fun accessOuter() = {
                println(zero) // error, cannot access outer class
                println(one)  // error, cannot access outer class
            }
        }
    }
}

我們在Nested類中，訪問不到Outer類中的變量zero，one。
如果想要訪問到，我們只需要在Nested類前面加上inner關鍵字修飾，表明這是一個嵌套的內部類。

7.12.2 內部類（Inner Class）

類可以標記爲 inner 以便能夠訪問外部類的成員。內部類會帶有一個對外部類的對象的引用：

class NestedClassesDemo {
class Outer {
        private val zero: Int = 0
        val one: Int = 1

        inner class Inner {
            fun accessOuter() = {
                println(zero) // works
                println(one) // works
            }
        }
}

測試代碼：

val innerClass = NestedClassesDemo.Outer().Inner().accessOuter()

我們可以看到，當訪問inner class Inner的時候，我們使用的是Outer().Inner(), 這是持有了Outer的對象引用。跟普通嵌套類直接使用類名訪問的方式區分。

7.12.3 匿名內部類（Annonymous Inner Class）

匿名內部類，就是沒有名字的內部類。既然是內部類，那麼它自然也是可以訪問外部類的變量的。

我們使用對象表達式創建一個匿名內部類實例：

class NestedClassesDemo {
class AnonymousInnerClassDemo {
            var isRunning = false
            fun doRun() {
                Thread(object : Runnable {
                    override fun run() {
                        isRunning = true
                        println("doRun : i am running, isRunning = $isRunning")
                    }
                }).start()
            }
    }
}

如果對象是函數式 Java 接口，即具有單個抽象方法的 Java 接口的實例，例如上面的例子中的Runnable接口：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

我們可以使用lambda表達式創建它，下面的幾種寫法都是可以的：

fun doStop() {
    var isRunning = true
    Thread({
        isRunning = false
        println("doStop: i am not running, isRunning = $isRunning")
    }).start()
}

fun doWait() {
    var isRunning = true

    val wait = Runnable {
        isRunning = false
        println("doWait: i am waiting, isRunning = $isRunning")
    }

    Thread(wait).start()
}

fun doNotify() {
    var isRunning = true

    val wait = {
        isRunning = false
        println("doNotify: i notify, isRunning = $isRunning")
    }

    Thread(wait).start()
}

測試代碼：

NestedClassesDemo.Outer.AnonymousInnerClassDemo().doRun()
NestedClassesDemo.Outer.AnonymousInnerClassDemo().doStop()
NestedClassesDemo.Outer.AnonymousInnerClassDemo().doWait()
NestedClassesDemo.Outer.AnonymousInnerClassDemo().doNotify()

輸出：

doRun : i am running, isRunning = true
doStop: i am not running, isRunning = false
doWait: i am waiting, isRunning = false
doNotify: i notify, isRunning = false

關於lambda表達式以及函數式編程，我們將在下一章中學習。

7.13 委託(Delegation)

7.13.1 代理模式（Proxy Pattern）

代理模式，也稱委託模式。

在代理模式中，有兩個對象參與處理同一個請求，接受請求的對象將請求委託給另一個對象來處理。代理模式是一項基本技巧，許多其他的模式，如狀態模式、策略模式、訪問者模式本質上是在特殊的場合採用了代理模式。

代理模式使得我們可以用聚合來替代繼承，它還使我們可以模擬mixin（混合類型）。委託模式的作用是將委託者與實際實現代碼分離出來，以達成解耦的目的。

一個代理模式的Java代碼示例：

package com.easy.kotlin;

interface JSubject {
    public void request();
}

class JRealSubject implements JSubject {
    @Override
    public void request() {
        System.out.println("JRealSubject Requesting");
    }
}

class JProxy implements JSubject {
    private JSubject subject = null;

    //通過構造函數傳遞代理者
    public JProxy(JSubject sub) {
        this.subject = sub;
    }

    @Override
    public void request() { //實現接口中定義的方法
        this.before();
        this.subject.request();
        this.after();
    }

    private void before() {
        System.out.println("JProxy Before Requesting ");
    }

    private void after() {
        System.out.println("JProxy After Requesting ");
    }
}

public class DelegateDemo {
    public static void main(String[] args) {
        JRealSubject jRealSubject = new JRealSubject();
        JProxy jProxy = new JProxy(jRealSubject);
        jProxy.request();
    }
}

輸出：

JProxy Before Requesting 
JRealSubject Requesting
JProxy After Requesting 

7.13.2 類的委託(Class Delegation)

就像支持單例模式的object對象一樣，Kotlin 在語言層面原生支持委託模式。

代碼示例：

package com.easy.kotlin

import java.util.*

interface Subject {
    fun hello()
}

class RealSubject(val name: String) : Subject {
    override fun hello() {
        val now = Date()
        println("Hello, REAL $name! Now is $now")
    }
}

class ProxySubject(val sb: Subject) : Subject by sb {
    override fun hello() {
        println("Before ! Now is ${Date()}")
        sb.hello()
        println("After ! Now is ${Date()}")
    }
}

fun main(args: Array<String>) {
    val subject = RealSubject("World")
    subject.hello()
    println("-------------------------")
    val proxySubject = ProxySubject(subject)
    proxySubject.hello()
}

在這個例子中，委託代理類 ProxySubject 繼承接口 Subject，並將其所有共有的方法委託給一個指定的對象sb :

class ProxySubject(val sb: Subject) : Subject by sb 

ProxySubject 的超類型Subject中的 by sb 表示 sb 將會在 ProxySubject 中內部存儲。

另外，我們在覆蓋重寫了函數override fun hello()。

測試代碼：

fun main(args: Array<String>) {
    val subject = RealSubject("World")
    subject.hello()
    println("-------------------------")
    val proxySubject = ProxySubject(subject)
    proxySubject.hello()
}

輸出：

Hello, REAL World! Now is Wed Jul 05 02:45:42 CST 2017
-------------------------
Before ! Now is Wed Jul 05 02:45:42 CST 2017
Hello, REAL World! Now is Wed Jul 05 02:45:42 CST 2017
After ! Now is Wed Jul 05 02:45:42 CST 2017

7.13.3 委託屬性 (Delegated Properties)

通常對於屬性類型，我們是在每次需要的時候手動聲明它們：

class NormalPropertiesDemo {
    var content: String = "NormalProperties init content"
}

那麼這個content屬性將會很“呆板”。屬性委託賦予了屬性富有變化的活力。

例如：

• 延遲屬性（lazy properties）: 其值只在首次訪問時計算
• 可觀察屬性（observable properties）: 監聽器會收到有關此屬性變更的通知
• 把多個屬性儲存在一個映射（map）中，而不是每個存在單獨的字段中。

委託屬性

Kotlin 支持 委託屬性:

class DelegatePropertiesDemo {
    var content: String by Content()

    override fun toString(): String {
        return "DelegatePropertiesDemo Class"
    }
}

class Content {
    operator fun getValue(delegatePropertiesDemo: DelegatePropertiesDemo, property: KProperty<*>): String {
        return "${delegatePropertiesDemo} property '${property.name}' = 'Balalala ... ' "
    }

    operator fun setValue(delegatePropertiesDemo: DelegatePropertiesDemo, property: KProperty<*>, value: String) {
        println("${delegatePropertiesDemo} property '${property.name}' is setting value: '$value'")
    }
}

在 var content: String by Content()中， by 後面的表達式的Content()就是該屬性委託的對象。content屬性對應的 get()（和 set()）會被委託給Content()的 operator fun getValue() 和 operator fun setValue() 函數，這兩個函數是必須的，而且得是操作符函數。

測試代碼：

val n = NormalPropertiesDemo()
println(n.content)
n.content = "Lao tze"
println(n.content)

val e = DelegatePropertiesDemo()
println(e.content) // call Content.getValue
e.content = "Confucius" // call Content.setValue
println(e.content) // call Content.getValue

輸出：

NormalProperties init content
Lao tze
DelegatePropertiesDemo Class property 'content' = 'Balalala ... ' 
DelegatePropertiesDemo Class property 'content' is setting value: 'Confucius'
DelegatePropertiesDemo Class property 'content' = 'Balalala ... 

懶加載屬性委託 lazy

lazy() 函數定義如下：

@kotlin.jvm.JvmVersion
public fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)

它接受一個 lambda 並返回一個 Lazy <T> 實例的函數，返回的實例可以作爲實現懶加載屬性的委託：

第一次調用 get() 會執行已傳遞給 lazy() 的 lamda 表達式並記錄下結果， 後續調用 get() 只是返回之前記錄的結果。

代碼示例：

val synchronizedLazyImpl = lazy({
    println("lazyValueSynchronized1  3!")
    println("lazyValueSynchronized1  2!")
    println("lazyValueSynchronized1  1!")
    "Hello, lazyValueSynchronized1 ! "
})

val lazyValueSynchronized1: String by synchronizedLazyImpl
println(lazyValueSynchronized1)
println(lazyValueSynchronized1)

val lazyValueSynchronized2: String by lazy {
    println("lazyValueSynchronized2  3!")
    println("lazyValueSynchronized2  2!")
    println("lazyValueSynchronized2  1!")
    "Hello, lazyValueSynchronized2 ! "
}

println(lazyValueSynchronized2)
println(lazyValueSynchronized2)

輸出：

lazyValueSynchronized1  3!
lazyValueSynchronized1  2!
lazyValueSynchronized1  1!
Hello, lazyValueSynchronized1 ! 
Hello, lazyValueSynchronized1 ! 

lazyValueSynchronized2  3!
lazyValueSynchronized2  2!
lazyValueSynchronized2  1!
Hello, lazyValueSynchronized2 ! 
Hello, lazyValueSynchronized2 ! 

默認情況下，對於 lazy 屬性的求值是同步的（synchronized）, 下面兩種寫法是等價的：

val synchronizedLazyImpl = lazy({
    println("lazyValueSynchronized1  3!")
    println("lazyValueSynchronized1  2!")
    println("lazyValueSynchronized1  1!")
    "Hello, lazyValueSynchronized1 ! "
})

val synchronizedLazyImpl2 = lazy(LazyThreadSafetyMode.SYNCHRONIZED, {
    println("lazyValueSynchronized1  3!")
    println("lazyValueSynchronized1  2!")
    println("lazyValueSynchronized1  1!")
    "Hello, lazyValueSynchronized1 ! "
})

該值是線程安全的。所有線程會看到相同的值。

如果初始化委託多個線程可以同時執行，不需要同步鎖，使用LazyThreadSafetyMode.PUBLICATION：

val lazyValuePublication: String by lazy(LazyThreadSafetyMode.PUBLICATION, {
    println("lazyValuePublication 3!")
    println("lazyValuePublication 2!")
    println("lazyValuePublication 1!")
    "Hello, lazyValuePublication ! "
})

而如果屬性的初始化是單線程的，那麼我們使用 LazyThreadSafetyMode.NONE 模式(性能最高)：

val lazyValueNone: String by lazy(LazyThreadSafetyMode.NONE, {
    println("lazyValueNone 3!")
    println("lazyValueNone 2!")
    println("lazyValueNone 1!")
    "Hello, lazyValueNone ! "
})

Delegates.observable 可觀察屬性委託

我們把屬性委託給Delegates.observable函數，當屬性值被重新賦值的時候， 觸發其中的回調函數 onChange。

該函數定義如下：

public inline fun <T> observable(initialValue: T, crossinline onChange: (property: KProperty<*>, oldValue: T, newValue: T) -> Unit):
        ReadWriteProperty<Any?, T> = object : ObservableProperty<T>(initialValue) {
            override fun afterChange(property: KProperty<*>, oldValue: T, newValue: T) = onChange(property, oldValue, newValue)
        }

代碼示例：

class PostHierarchy {
    var level: String by Delegates.observable("P0",
            { property: KProperty<*>,
              oldValue: String,
              newValue: String ->
                println("$oldValue -> $newValue")
            })
}

測試代碼：

val ph = PostHierarchy()
ph.level = "P1"
ph.level = "P2"
ph.level = "P3"
println(ph.level) // P3

輸出：

P0 -> P1
P1 -> P2
P2 -> P3
P3

我們可以看出，屬性level每次賦值，都回調了Delegates.observable中的lambda表達式所寫的onChange函數。

Delegates.vetoable 可否決屬性委託

這個函數定義如下：

public inline fun <T> vetoable(initialValue: T, crossinline onChange: (property: KProperty<*>, oldValue: T, newValue: T) -> Boolean):
        ReadWriteProperty<Any?, T> = object : ObservableProperty<T>(initialValue) {
            override fun beforeChange(property: KProperty<*>, oldValue: T, newValue: T): Boolean = onChange(property, oldValue, newValue)
        }

當我們把屬性委託給這個函數時，我們可以通過onChange函數的返回值是否爲true， 來選擇屬性的值是否需要改變。

代碼示例:

class PostHierarchy {
    var grade: String by Delegates.vetoable("T0", {
        property, oldValue, newValue ->
        true
    })

    var notChangeGrade: String by Delegates.vetoable("T0", {
        property, oldValue, newValue ->
        false
    })
}

測試代碼：

ph.grade = "T1"
ph.grade = "T2"
ph.grade = "T3"
println(ph.grade) // T3

ph.notChangeGrade = "T1"
ph.notChangeGrade = "T2"
ph.notChangeGrade = "T3"
println(ph.notChangeGrade) // T0

我們可以看出，當onChange函數返回值是false的時候，對屬性notChangeGrade的賦值都沒有生效，依然是原來的默認值T0 。

Delegates.notNull 非空屬性委託

我們也可以使用委託來實現屬性的非空限制：

var name: String by Delegates.notNull()

這樣name屬性就被限制爲不能爲null，如果被賦值null，編譯器直接報錯：

ph.name = null // error 
Null can not be a value of a non-null type String

屬性委託給Map映射

我們也可以把屬性委託給Map：

class Account(val map: Map<String, Any?>) {
    val name: String by map
    val password: String by map
}

測試代碼：

val account = Account(mapOf(
            "name" to "admin",
            "password" to "admin"
    ))

println("Account(name=${account.name}, password = ${account.password})")

輸出：

Account(name=admin, password = admin)

如果是可變屬性，這裏也可以把只讀的 Map 換成 MutableMap ：

class MutableAccount(val map: MutableMap<String, Any?>) {
    var name: String by map
    var password: String by map
}

測試代碼：

val maccount = MutableAccount(mutableMapOf(
            "name" to "admin",
            "password" to "admin"
))

maccount.password = "root"
println("MutableAccount(name=${maccount.name}, password = ${maccount.password})")

輸出：

MutableAccount(name=admin, password = root)

本章小結

本章我們介紹了Kotlin面向對象編程的特性： 類與構造函數、抽象類與接口、繼承以及多重繼承等基礎知識，同時介紹了Kotlin中的註解類、枚舉類、數據類、密封類、嵌套類、內部類、匿名內部類等特性類。最後我們學習了Kotlin中對單例模式、委託模式的語言層面上的內置支持：object對象、委託。

總的來說，Kotlin相比於Java的面向對象編程，增加不少有趣的功能與特性支持，這使得我們代碼寫起來更加方便快捷了。

我們知道，在Java 8 中，引進了對函數式編程的支持：Lambda表達式、Function接口、stream API等，而在Kotlin中，對函數式編程的支持更加全面豐富，代碼寫起來也更加簡潔優雅。下一章中，我們來一起學習Kotlin的函數式編程。

本章示例代碼工程：https://github.com/EasyKotlin/chatper7_oop