第7章 面向?qū)ο缶幊?#xff08;OOP）

---

《Kotlin極簡教程》正式上架：

點擊這里 > 去京東商城購買閱讀

點擊這里 > 去天貓商城購買閱讀

非常感謝您親愛的讀者，大家請多支持！！！有任何問題，歡迎隨時與我交流~

---

在前面的章節(jié)中，我們學習了Kotlin的語言基礎知識、類型系統(tǒng)、集合類以及泛型相關的知識。在本章節(jié)以及下一章中，我們將一起來學習Kotlin對面向?qū)ο缶幊桃约昂瘮?shù)式編程的支持。

7.1 面向?qū)ο缶幊趟枷?/h2>

7.1.1 一切皆是映射

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

一切皆是映射

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

就好比通過的電子電路中的電平進行01邏輯映射，于是有了布爾代數(shù)，數(shù)字邏輯電路系統(tǒng)；

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

通過匯編語言的向上抽象一層編譯解釋器，于是有了pascal，fortran，C語言；
再對核心函數(shù)api進行封裝形成開發(fā)包（Development Kit), 于是有了Java，C++ 。

從面向過程到面向?qū)ο?#xff0c;再到設計模式，架構(gòu)設計，面向服務，Sass/Pass/Iass等等的思想，各種軟件理論思想五花八門，但萬變不離其宗——

• 你要解決一個怎樣的問題？
• 你的問題領域是怎樣的？
• 你的模型（數(shù)據(jù)結(jié)構(gòu)）是什么？
• 你的算法是什么？
• 你對這個世界的本質(zhì)認知是怎樣的？
• 你的業(yè)務領域的邏輯問題，流程是什么？
  等等。

Grady Booch：我對OO編程的目標從來就不是復用。相反，對我來說，對象提供了一種處理復雜性的方式。這個問題可以追溯到亞里士多德：您把這個世界視為過程還是對象？在OO興起運動之前，編程以過程為中心--例如結(jié)構(gòu)化設計方法。然而，系統(tǒng)已經(jīng)到達了超越其處理能力的復雜性極點。有了對象，我們能夠通過提升抽象級別來構(gòu)建更大的、更復雜的系統(tǒng)--我認為，這才是面向?qū)ο缶幊踢\動的真正勝利。

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

接著， 創(chuàng)造了助記符 —— 匯編語言， 比機器指令更容易記憶；

再接著， 創(chuàng)造了編譯器、解釋器和計算機高級語言， 能夠以人類友好自然的方式去編寫程序， 在犧牲少量性能的情況下， 獲得比匯編語言更強且更容易使用的語句控制能力：條件、分支、循環(huán)， 以及更多的語言特性： 指針、結(jié)構(gòu)體、聯(lián)合體、枚舉等， 還創(chuàng)造了函數(shù)， 能夠?qū)⒁幌盗兄噶罘庋b成一個獨立的邏輯塊反復使用；

逐漸地，產(chǎn)生了面向過程的編程方法；

后來， 人們發(fā)現(xiàn)將數(shù)據(jù)和邏輯封裝成對象， 更接近于現(xiàn)實世界， 且更容易維護大型軟件， 又出現(xiàn)了面向?qū)ο蟮木幊陶Z言和編程方法學， 增加了新的語言特性： 繼承、 多態(tài)、 模板、 異常錯誤。

為了不必重復開發(fā)常見工具和任務， 人們創(chuàng)造和封裝了容器及算法、SDK， 垃圾回收器， 甚至是并發(fā)庫；

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

為了更高效率地開發(fā)可靠的軟件和應用程序， 人們逐漸構(gòu)建了代碼編輯器、 IDE、 代碼版本管理工具、公共庫、應用框架、 可復用組件、系統(tǒng)規(guī)范、網(wǎng)絡協(xié)議、 語言標準等， 針對遇到的問題提出了許多不同的思路和解決方案， 并總結(jié)提煉成特定的技術(shù)和設計模式， 還探討和形成了不少軟件開發(fā)過程， 用來保證最終發(fā)布的軟件質(zhì)量。 盡管編寫的這些軟件和工具還存在不少 BUG ，但是它們都“奇跡般地存活”， 并共同構(gòu)建了今天蔚為壯觀的互聯(lián)網(wǎng)時代的電商，互聯(lián)網(wǎng)金融，云計算，大數(shù)據(jù)，物聯(lián)網(wǎng)，機器智能等等的“虛擬世界”。

7.1.2 二進制01與易經(jīng)陰陽

二進制數(shù)是用0和1兩個數(shù)碼來表示的數(shù)。它的基數(shù)為2，進位規(guī)則是“逢二進一”，借位規(guī)則是“借一當二”，由18世紀德國數(shù)理哲學大師萊布尼茲發(fā)現(xiàn)。當前的計算機系統(tǒng)使用的基本上是二進制系統(tǒng)。

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

二進制的發(fā)現(xiàn)直接導致了電子計算器和計算機的發(fā)明，并讓計算機得到了迅速的普及，進入各行各業(yè)，成為人類生活和生產(chǎn)的重要工具。

二進制的實質(zhì)是通過兩個數(shù)字“0”和“1”來描述事件。在人類的生產(chǎn)、生活等許多領域，我們可以通過計算機來虛擬地描述現(xiàn)實中存在的事件，并能通過給定的條件和參數(shù)模擬事件變化的規(guī)律。二進制的計算機幾乎是萬能的，能將我們生活的現(xiàn)實世界完美復制，并且還能根據(jù)我們?nèi)祟惤o定的條件模擬在現(xiàn)實世界難以實現(xiàn)的各種實驗。

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

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

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

所以說，編程的本質(zhì)跟大自然創(chuàng)造萬物的本質(zhì)是一樣的。

7.1.3 從面向過程到面向?qū)ο?/h3>

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

面向過程編程

結(jié)構(gòu)化編程思想的核心：功能分解（自頂向下，逐層細化）。

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

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

第一步編出的程序抽象度最高，第二步編出的程序抽象度有所降低…… 最后一步編出的程序即為可執(zhí)行的程序。

用這種方法編程，似乎復雜，實際上優(yōu)點很多，可使程序易讀、易寫、易調(diào)試、易維護、易保證其正確性及驗證其正確性。

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

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

程序 = 數(shù)據(jù)結(jié)構(gòu) + 算法

面向?qū)ο缶幊?/h4>

面向?qū)ο缶幊趟枷氲暮诵?#xff1a;應對變化，提高復用。

阿倫·凱（Alan Kay）：面向?qū)ο缶幊趟枷氲膭?chuàng)始人。2003年因在面向?qū)ο缶幊躺纤龅木薮筘暙I而獲得圖靈獎。

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

阿倫·凱是Smalltalk面向?qū)ο缶幊陶Z言的發(fā)明人之一，也是面向?qū)ο缶幊趟枷氲膭?chuàng)始人之一，同時，他還是筆記本電腦最早的構(gòu)想者和現(xiàn)代Windows GUI的建筑師。最早提出PC概念和互聯(lián)網(wǎng)的也是阿倫·凱，所以人們都尊稱他為“預言大師”。他是當今IT界屈指可數(shù)的技術(shù)天才級人物。

面向?qū)ο缶幊趟枷胫饕菑陀眯院挽`活性（彈性）。復用性是面向?qū)ο缶幊痰囊粋€主要機制。靈活性主要是應對變化的特性，因為客戶的需求是不斷改變的，怎樣適應客戶需求的變化，這是軟件設計靈活性或者說是彈性的問題。

Java是一種面向?qū)ο缶幊陶Z言，它基于Smalltalk語言，作為OOP語言，它具有以下五個基本特性：

1.萬物皆對象，每一個對象都會存儲數(shù)據(jù)，并且可以對自身執(zhí)行操作。因此，每一個對象包含兩部分：成員變量和成員方法。在成員方法中可以改變成員變量的值。

2.程序是對象的集合，他們通過發(fā)送消息來告知彼此所要做的事情，也就是調(diào)用相應的成員函數(shù)。

3.每一個對象都有自己的由其他對象所構(gòu)成的存儲，也就是說在創(chuàng)建新對象的時候可以在成員變量中使用已存在的對象。

4.每個對象都擁有其類型，每個對象都是某個類的一個實例，每一個類區(qū)別于其它類的特性就是可以向它發(fā)送什么類型的消息，也就是它定義了哪些成員函數(shù)。

5.某一個特定類型的所有對象都可以接受同樣的消息。另一種對對象的描述為：對象具有狀態(tài)(數(shù)據(jù)，成員變量)、行為(操作，成員方法)和標識(成員名，內(nèi)存地址)。

面向?qū)ο笳Z言其實是對現(xiàn)實生活中的實物的抽象。

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

我們經(jīng)常說一些代碼片段是優(yōu)雅的或美觀的，實際上意味著它們更容易被人類有限的思維所處理。

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

代碼塊的“表面積”是是我們復合代碼塊時所需要的信息（接口API協(xié)議定義）。代碼塊的“體積”就是接口內(nèi)部的實現(xiàn)邏輯（API背后的實現(xiàn)代碼）。

在面向?qū)ο缶幊讨?#xff0c;一個理想的對象應該是只暴露它的抽象接口（純表面， 無體積），其方法則扮演箭頭的角色。如果為了理解一個對象如何與其他對象進行復合，當你發(fā)現(xiàn)不得不深入挖掘?qū)ο蟮膶崿F(xiàn)之時，此時你所用的編程范式的原本優(yōu)勢就蕩然無存了。

面向組件和面向服務

• 面向組件

我們知道面向?qū)ο笾С种赜?#xff0c;但是重用的單元很小，一般是類；而面向組件則不同，它可以重用多個類甚至一個程序。也就是說面向組件支持更大范圍內(nèi)的重用，開發(fā)效率更高。如果把面向?qū)ο蟊茸髦赜昧慵?#xff0c;那么面向組件則是重用部件。

• 面向服務

將系統(tǒng)進行功能化，每個功能提供一種服務。現(xiàn)在非常流行微服務MicroService技術(shù)以及SOA（面向服務架構(gòu)）技術(shù)。

面向過程（Procedure）→面向?qū)ο?#xff08;Object）→ 面向組件（Component） →面向服務（Service）

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

解決問題的復雜程度直接取決于抽象的種類及質(zhì)量。過將結(jié)構(gòu)、性質(zhì)不同的底層實現(xiàn)進行封裝，向上提供統(tǒng)一的API接口，讓使用者覺得就是在使用一個統(tǒng)一的資源，或者讓使用者覺得自己在使用一個本來底層不直接提供、“虛擬”出來的資源。

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

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

所謂“面向?qū)ο笳Z言”，其實經(jīng)典的“過程式語言”（比如Pascal，C），也能體現(xiàn)面向?qū)ο蟮乃枷搿Ｋ^“類”和“對象”，就是C語言里面的抽象數(shù)據(jù)類型結(jié)構(gòu)體（struct）。

而面向?qū)ο蟮亩鄳B(tài)是唯一相比struct多付出的代價，也是最重要的特性。這就是SmallTalk、Java這樣的面向?qū)ο笳Z言所提供的特性。

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

在面向?qū)ο蟮木幊淌澜缋?#xff0c;下面的這個公式

程序 = 算法 + 數(shù)據(jù)結(jié)構(gòu)

可以簡單重構(gòu)成：

程序 = 基于對象操作的算法 + 以對象為最小單位的數(shù)據(jù)結(jié)構(gòu)

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

在面向?qū)ο蟮某绦蛟O計中，我們便少不了集合類容器。容器就用來存放一類有共同抽象概念的東西。這里說有共同概念的東西（而沒有說對象），其實，就是我們上一個章節(jié)中講到的泛型。這樣對于一個通用的算法，我們就可以最大化的實現(xiàn)復用，作用于的集合。

面向?qū)ο蟮谋举|(zhì)就是讓對象有多態(tài)性，把不同對象以同一特性來歸組，統(tǒng)一處理。至于所謂繼承、虛表、等等概念，只是其實現(xiàn)的細節(jié)。

在遵循這些面向?qū)ο笤O計原則基礎上，前輩們總結(jié)出一些解決不同問題場景的設計模式，以GOF的23中設計模式最為知名。

我們用一幅圖簡單概括一下面向?qū)ο缶幊痰闹R框架：

講了這么多思考性的思想層面的東西，我們下面來開始Kotlin的面向?qū)ο缶幊痰膶W習。Kotlin對面向?qū)ο缶幊淌峭耆С值摹?/p>

7.2 類與構(gòu)造函數(shù)

Kotlin和Java很相似，也是一種面向?qū)ο蟮恼Z言。下面我們來一起學習Kotlin的面向?qū)ο蟮奶匦浴Ｈ绻煜ava或者C++、C#中的類，您可以很快上手。同時，您也將看到Kotlin與Java中的面向?qū)ο缶幊痰囊恍┎煌奶匦浴?/p>

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

另外，嵌套類并不是默認在內(nèi)部的。它們不包含外部類的隱式引用。

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

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

Kotlin類的成員可以包含：

• 構(gòu)造函數(shù)和初始化塊
• 屬性
• 函數(shù)
• 嵌套類和內(nèi)部類
• 對象聲明

等。

7.2.1 聲明類

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

class World

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

7.2.2 構(gòu)造函數(shù)

在 Kotlin 中，一個類可以有一個

• 主構(gòu)造函數(shù)（primary constructor）和一個或多個
• 次構(gòu)造函數(shù)（secondary constructor）。

主構(gòu)造函數(shù)

主構(gòu)造函數(shù)是類頭的一部分，直接放在類名后面：

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

如果主構(gòu)造函數(shù)沒有任何注解或者可見性修飾符，可以省略這個 constructor 關鍵字。如果構(gòu)造函數(shù)有注解或可見性修飾符，這個 constructor 關鍵字是必需的，并且這些修飾符在它前面：

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

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

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

open class Student constructor(var name: String, var age: Int) : Any() {init {println("Student{name=$name, age=$age} created!")}...}

主構(gòu)造的參數(shù)可以在初始化塊中使用,也可以在類體內(nèi)聲明的屬性初始化器中使用。

次構(gòu)造函數(shù)

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

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

如果類有一個主構(gòu)造函數(shù)，那么每個次構(gòu)造函數(shù)需要委托給主構(gòu)造函數(shù)， 委托到同一個類的另一個構(gòu)造函數(shù)用 this 關鍵字即可：

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

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

私有主構(gòu)造函數(shù)

我們?nèi)绻Ｍ@個構(gòu)造函數(shù)是私有的，我們可以如下聲明：

class DontCreateMe private constructor() { }

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

val dontCreateMe = DontCreateMe() // cannot access it

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

7.2.2 類的屬性

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

class World1 {val yin: Intval yang: Int }

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

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

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

class World1 {val yin: Int = 0val 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中的類的字段自動帶有g(shù)etter方法和setter方法。而且寫起來比Java要簡潔的多。

7.2.3 函數(shù)（方法）

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

class World2 {val yin: Int = 0val yang: Int = 1fun plus(): Int {return yin + yang} }val w2 = World2() println(w2.plus()) // 輸出 1

7.3 抽象類

7.3.1 抽象類的定義

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

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

abstract class Person(var name: String, var age: Int) : Any() {abstract var addr: Stringabstract val weight: Floatabstract fun doEat()abstract fun doWalk()fun doSwim() {println("I am Swimming ... ")}open fun doSleep() {println("I am Sleeping ... ")} }

7.3.2 抽象函數(shù)

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

如果一個函數(shù)想要設計成能被重寫，例如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.0foverride 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 ... ") // } }

抽象函數(shù)是一種特殊的函數(shù)：它只有聲明，而沒有具體的實現(xiàn)。抽象函數(shù)的聲明格式為：

abstract fun doEat()

關于抽象函數(shù)的特征，我們簡單總結(jié)如下：

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

7.3.3 抽象屬性

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

abstract var addr : String abstract val weight : Float

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

抽象屬相在抽象類中不能被初始化

如果在子類中沒有主構(gòu)造函數(shù)，要對抽象屬性手動初始化。如果子類中有主構(gòu)造函數(shù)，抽象屬性可以在主構(gòu)造函數(shù)中聲明。

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

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

也就是說，這三個函數(shù)

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

默認的都是public的。

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

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

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

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

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 ... ")} }

如果子類沒有實現(xiàn)父類的抽象函數(shù)，則必須將子類也定義為為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函數(shù)沒有實現(xiàn)父類的抽象函數(shù)，那么我們在子類中把它依然定義為抽象函數(shù)。相應地這個子類，也成為了抽象子類，需要使用abstract關鍵字來聲明。

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

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

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

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

class Teacher(name: String, age: Int) : Person(name, age) {override var addr: String = "HangZhou"override val weight: Float = 100.0foverride 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 的接口類似。與抽象類相比，他們都可以包含抽象的方法以及方法的實現(xiàn):

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

7.4.2 實現(xiàn)接口

接口是沒有構(gòu)造函數(shù)的。我們使用冒號: 語法來實現(xiàn)一個接口，如果有多個用，逗號隔開：

class ProjectServiceImpl : ProjectService class ProjectMilestoneServiceImpl : ProjectService, MilestoneService

我們也可以實現(xiàn)多個接口：

class Projectclass Milestoneinterface ProjectService {val name: Stringval owner: Stringfun save(project: Project)fun print() {println("I am project")} }interface MilestoneService {val name: Stringfun save(milestone: Milestone)fun print() {println("I am Milestone")} }class ProjectMilestoneServiceImpl : ProjectService, MilestoneService {override val name: Stringget() = "ProjectMilestone"override val owner: Stringget() = "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.對于父類的包訪問權(quán)限成員變量，如果子類和父類在同一個包下，則子類能夠繼承；否則，子類不能夠繼承；

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

7.4.3 覆蓋沖突

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

在重寫print()時，因為我們實現(xiàn)的ProjectService、MilestoneService都有一個print()函數(shù)，當我們直接使用super.print()時，編譯器是無法知道我們想要調(diào)用的是那個里面的print函數(shù)的，這個我們叫做覆蓋沖突：

這個時候，我們可以使用下面的語法來調(diào)用：

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

7.4.4 接口中的屬性

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

在企業(yè)應用中，大多數(shù)的類型都是無狀態(tài)的，如：Controller、ApplicationService、DomainService、Repository等。

因為接口沒有狀態(tài)， 所以它的屬性是無狀態(tài)的。

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: Stringget() = "MilestoneServiceImpl name"override fun save(milestone: Milestone) {println("save Milestone")} }

7.5 抽象類和接口的差異

概念上的區(qū)別

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

語法層面上的區(qū)別

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

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

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

設計層面上的區(qū)別

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

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

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

• 對于抽象類，如果需要添加新的方法，可以直接在抽象類中添加具體的實現(xiàn)，子類可以不進行變更；
• 而對于接口則不行，如果接口進行了變更，則所有實現(xiàn)這個接口的類都必須進行相應的改動。

實際應用上的差異

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

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

7.6 繼承

繼承是面向?qū)ο缶幊痰囊粋€重要的方式，因為通過繼承，子類就可以擴展父類的功能。

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

7.6.1 open類

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

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

open class Base{ }

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

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

class SubClass : Base(){ }

如果父類有構(gòu)造函數(shù)，那么必須在子類的主構(gòu)造函數(shù)中進行繼承，沒有的話則可以選擇主構(gòu)造函數(shù)或二級構(gòu)造函數(shù)

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

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

open fun doSomething() {}

然后通過override標記實現(xiàn)重寫

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

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

override重寫的函數(shù)也是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一樣，沒有采用多繼承，任何一個子類僅允許一個父類存在，而在多繼承的問題場景下，使用實現(xiàn)多個interface 組合的方式來實現(xiàn)多繼承的功能。

代碼示例：

package com.easy.kotlin/*** Created by jack on 2017/7/2.*/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()函數(shù)功能；實現(xiàn)了Runnable接口，擁有了doRun()函數(shù)規(guī)范；實現(xiàn)了Flyable接口，擁有了doFly()函數(shù)規(guī)范。

在這里，我們通過實現(xiàn)多個接口，組合完成了的多個功能，而不是設計多個層次的復雜的繼承關系。

7.7 枚舉類

Kotlin的枚舉類定義如下：

public abstract class Enum<E : Enum<E>>(name: String, ordinal: Int): Comparable<E> {companion object {}public final val name: Stringpublic final val ordinal: Intpublic override final fun compareTo(other: E): Intprotected final fun clone(): Anypublic override final fun equals(other: Any?): Booleanpublic override final fun hashCode(): Intpublic override fun toString(): String }

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

public final val name: Stringpublic final val ordinal: Int

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

同時，我們可以看出枚舉類還實現(xiàn)了Comparable<E>接口。

7.7.1 枚舉類基本用法

枚舉類的最基本的用法是實現(xiàn)類型安全的枚舉：

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()函數(shù)來列出枚舉的所有值：

@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

我們直接聲明了一個簡單枚舉類，我們使用遍歷函數(shù) 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 ： 指定這個注解可被用于哪些元素(類, 函數(shù), 屬性, 表達式, 等等.);
• @Retention ： 指定這個注解的信息是否被保存到編譯后的 class 文件中, 以及在運行時是否可以通過反
  射訪問到它；
• @Repeatable： 允許在單個元素上多次使用同一個注解；
• @MustBeDocumented ： 表示這個注解是公開 API 的一部分, 在自動產(chǎn)生的 API 文檔的類或者函數(shù)簽名中, 應該包含這個注解的信息。

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

7.8.2 使用注解

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

@MagicClass class Foo @MagicConstructor constructor() {constructor(index: Int) : this() {this.index = index}@MagicClass var index: Int = 0@MagicFunction fun magic(@MagicClass name: String) {} }

注解在主構(gòu)造器上，主構(gòu)造器必須加上關鍵字 “constructor”

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

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

7.9.1 單例模式(Singleton)

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

我們用Java實現(xiàn)一個簡單的單例類的代碼如下：

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

測試代碼：

Singleton singleton1 = Singleton.getInstance();

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

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

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

7.9.2 object對象

Kotlin中沒有?靜態(tài)屬性和方法，但是也提供了實現(xiàn)類似于單例的功能，我們可以使用關鍵字?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.usernameval adminPassword = AdminUser.md5Password()println(adminUser) // adminprintln(adminPassword) // g+0yLfaPVYxUf6TMIdXFXw==，這個值具體運行時會變化

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

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

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

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

不能像下面這樣使用構(gòu)造函數(shù)：

>>> 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 {@NotNullprivate static final String username = "admin";@NotNullprivate static final String password = "admin";public static final User INSTANCE;@NotNullpublic final String getUsername() {return username;}@NotNullpublic 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") // 輸出文件的內(nèi)容

同樣的，我們只能通過類的名稱來直接訪問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) // 同步getprintln("html1=${html1}") HttpUtils.getAsync(url) // 異步get

7.9.4 匿名object

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

fun distance(x: Double, y: Double): Double {val porigin = object {var x = 0.0var 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 {// 私有函數(shù)，返回的是匿名object類型private fun privateFoo() = object {val x: String = "x"}// 公有函數(shù)，返回的類型是 Anyfun 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 匿名內(nèi)部類類似，object對象表達式中的代碼可以訪問來自包含它的作用域的變量（與 Java 不同的是，這不限于 final 變量）:

fun countCompare() {var list = mutableListOf(1, 4, 3, 7, 11, 9, 10, 20)var countCompare = 0Collections.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 classfun create(): MyClass = MyClass()} }

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

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

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

ClassB.Companion.indexClassB.Companion.create()ClassB.Companion.get()

其中， Companion可以省略不寫：

ClassB.indexClassB.create()ClassB.get()

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

class ClassC {var index = 0fun get(index: Int): Int {return 0}companion object CompanyC {fun create(): ClassC = ClassC()fun get() = "Hi, I am CompanyC"} }

測試代碼：

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

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

即使伴生對象的成員看起來像其他語言的靜態(tài)成員，在運行時他們?nèi)匀皇钦鎸崒ο蟮膶嵗蓡T。而且，還可以實現(xiàn)接口：

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中的靜態(tài)成員和靜態(tài)方法的話，我們可以用：

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

7.10 sealed 密封類

7.10.1 為什么使用密封類

就像我們?yōu)槭裁匆胑num類型一樣，比如你有一個enum類型 MoneyUnit，定義了元、角、分這些單位。枚舉就是為了控制住你所有要的情況是正確的，而不是用硬編碼方式寫成字符串“元”，“角”，“分”。

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

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

7.10.1 聲明密封類

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

sealed class Expressionclass 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.0is Const -> expr.numberis Sum -> eval(expr.e1) + eval(expr.e2)is Multiply -> eval(expr.e1) * eval(expr.e2)NaN -> Double.NaN // 不再需要 `else` 子句，因為我們已經(jīng)覆蓋了所有的情況 }

測試代碼：

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 數(shù)據(jù)類

7.11.1 構(gòu)造函數(shù)中的 val/var

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

寫法一：

class Aook(name: String)

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

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

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

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

測試代碼：

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

對應的Java實現(xiàn)代碼是：

public final class Cook {@NotNullprivate final String name;@NotNullpublic 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)

構(gòu)造函數(shù)中帶var、val修飾的變量，Kotlin編譯器會自動為它們生成getter、setter函數(shù)。

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

public final class Dook {@NotNullprivate final String name;@NotNullpublic final String getName() {return this.name;}public Dook(@NotNull String name) {Intrinsics.checkParameterIsNotNull(name, "name");super();this.name = name;} }public final class Eook {@NotNullprivate String name;@NotNullpublic 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.nameval eook = Eook("Eook")eook.name

下面我們來學習一下Kotlin中的數(shù)據(jù)類： data class 。

7.11.2 領域?qū)嶓w類

我們寫Java代碼的時候，會經(jīng)常創(chuàng)建一些只保存數(shù)據(jù)的類。比如說：

• POJO類：POJO全稱是Plain Ordinary Java Object / Pure Old Java Object，中文可以翻譯成：普通Java類，具有一部分getter/setter方法的那種類就可以稱作POJO。
• DTO類：Data Transfer Object，數(shù)據(jù)傳輸對象類，泛指用于展示層與服務層之間的數(shù)據(jù)傳輸對象。
• VO類：VO有兩種說法,一個是ViewObject,一個是ValueObject。
• PO類：Persisent Object，持久對象。它們是由一組屬性和屬性的get和set方法組成。PO是在持久層所使用，用來封裝原始數(shù)據(jù)。
• BO類：Business Object，業(yè)務對象層，表示應用程序領域內(nèi)“事物”的所有實體類。
• DO類：Domain Object，領域?qū)ο?#xff0c;就是從現(xiàn)實世界中抽象出來的有形或無形的業(yè)務實體。

等等。

這些我們統(tǒng)稱為領域模型中的實體類。最簡單的實體類是POJO類，含有屬性及屬性對應的set和get方法，實體類常見的方法還有用于輸出自身數(shù)據(jù)的toString方法。

7.11.3 數(shù)據(jù)類data class的概念

在 Kotlin 中，也有對應這樣的領域?qū)嶓w類的概念，并在語言層面上做了支持，叫做數(shù)據(jù)類 ：

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是必須要帶上的。因為編譯器要把主構(gòu)造函數(shù)中聲明的所有屬性，自動生成以下函數(shù)：

equals()/hashCode() toString() : 格式是 User(name=Jacky, gender=Male, age=10) componentN() 函數(shù) : 按聲明順序?qū)谒袑傩詂omponent1()、component2() ... copy() 函數(shù)

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

測試代碼：

val book = Book("Book")book.namebook.copy("Book2")val jack = User("Jack", "Male", 1)jack.namejack.genderjack.agejack.toString()jack.validate()val olderJack = jack.copy(age = 2)val anotherJack = jack.copy(name = "Jacky", age = 10)

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

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

7.11.4 數(shù)據(jù)類的限制

數(shù)據(jù)類有以下的限制要求：

1.主構(gòu)造函數(shù)需要至少有一個參數(shù)。下面的寫法是錯誤的：

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

2.主構(gòu)造函數(shù)的所有參數(shù)需要標記為 val 或 var；

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

跟普通類一樣，數(shù)據(jù)類也可以有次級構(gòu)造函數(shù)：

data class LoginUser(val name: String = "", val password: String = "") : DBase(), IBaseA, IBaseB {var isActive = trueconstructor(name: String, password: String, isActive: Boolean) : this(name, password) {this.isActive = isActive}... }

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

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

數(shù)據(jù)類只能是final的：

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

4.在1.1之前數(shù)據(jù)類只能實現(xiàn)接口。自 1.1 起，數(shù)據(jù)類可以擴展其他類。代碼示例：

open class DBase interface IBaseA interface IBaseBdata 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函數(shù)，則會默認輸出：

LoginUser(name=Admin, password=admin)

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

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

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

val loginUser3 = LoginUser()loginUser3.nameloginUser3.password

7.11.5 數(shù)據(jù)類的解構(gòu)

解構(gòu)相當于 Component 函數(shù)的逆向映射：

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

輸出：

Helen, Female, 15 years of age

7.11.6 標準數(shù)據(jù)類Pair 和Triple

標準庫中的二元組 Pair類就是一個數(shù)據(jù)類：

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類還增加了轉(zhuǎn)換成List的擴展函數(shù)：

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 = 0val one: Int = 1class Nested {fun getTwo() = 2class Nested1 {val three = 3fun getFour() = 4}}} }

測試代碼：

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

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

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

class NestedClassesDemo { class Outer {private val zero: Int = 0val one: Int = 1class Nested {fun getTwo() = 2fun accessOuter() = {println(zero) // error, cannot access outer classprintln(one) // error, cannot access outer class}} } }

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

7.12.2 內(nèi)部類（Inner Class）

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

class NestedClassesDemo { class Outer {private val zero: Int = 0val one: Int = 1inner class Inner {fun accessOuter() = {println(zero) // worksprintln(one) // works}} }

測試代碼：

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

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

7.12.3 匿名內(nèi)部類（Annonymous Inner Class）

匿名內(nèi)部類，就是沒有名字的內(nèi)部類。既然是內(nèi)部類，那么它自然也是可以訪問外部類的變量的。

我們使用對象表達式創(chuàng)建一個匿名內(nèi)部類實例：

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

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

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

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

fun doStop() {var isRunning = trueThread({isRunning = falseprintln("doStop: i am not running, isRunning = $isRunning")}).start()}fun doWait() {var isRunning = trueval wait = Runnable {isRunning = falseprintln("doWait: i am waiting, isRunning = $isRunning")}Thread(wait).start()}fun doNotify() {var isRunning = trueval wait = {isRunning = falseprintln("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表達式以及函數(shù)式編程，我們將在下一章中學習。

7.13 委托(Delegation)

7.13.1 代理模式（Proxy Pattern）

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

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

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

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

package com.easy.kotlin;/*** Created by jack on 2017/7/5.*/ interface JSubject {public void request(); }class JRealSubject implements JSubject {@Overridepublic void request() {System.out.println("JRealSubject Requesting");} }class JProxy implements JSubject {private JSubject subject = null;//通過構(gòu)造函數(shù)傳遞代理者public JProxy(JSubject sub) {this.subject = sub;}@Overridepublic void request() { //實現(xiàn)接口中定義的方法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.kotlinimport java.util.*/*** Created by jack on 2017/7/5.*/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 中內(nèi)部存儲。

另外，我們在覆蓋重寫了函數(shù)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）: 監(jiān)聽器會收到有關此屬性變更的通知
• 把多個屬性儲存在一個映射（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() 函數(shù)，這兩個函數(shù)是必須的，而且得是操作符函數(shù)。

測試代碼：

val n = NormalPropertiesDemo()println(n.content)n.content = "Lao tze"println(n.content)val e = DelegatePropertiesDemo()println(e.content) // call Content.getValuee.content = "Confucius" // call Content.setValueprintln(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() 函數(shù)定義如下：

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

它接受一個 lambda 并返回一個 Lazy <T> 實例的函數(shù)，返回的實例可以作為實現(xiàn)懶加載屬性的委托：

第一次調(diào)用 get() 會執(zhí)行已傳遞給 lazy() 的 lamda 表達式并記錄下結(jié)果， 后續(xù)調(diào)用 get() 只是返回之前記錄的結(jié)果。

代碼示例：

val synchronizedLazyImpl = lazy({println("lazyValueSynchronized1 3!")println("lazyValueSynchronized1 2!")println("lazyValueSynchronized1 1!")"Hello, lazyValueSynchronized1 ! "})val lazyValueSynchronized1: String by synchronizedLazyImplprintln(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 ! "})

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

如果初始化委托多個線程可以同時執(zhí)行，不需要同步鎖，使用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函數(shù)，當屬性值被重新賦值的時候， 觸發(fā)其中的回調(diào)函數(shù) onChange。

該函數(shù)定義如下：

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每次賦值，都回調(diào)了Delegates.observable中的lambda表達式所寫的onChange函數(shù)。

Delegates.vetoable 可否決屬性委托

這個函數(shù)定義如下：

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)}

當我們把屬性委托給這個函數(shù)時，我們可以通過onChange函數(shù)的返回值是否為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) // T3ph.notChangeGrade = "T1"ph.notChangeGrade = "T2"ph.notChangeGrade = "T3"println(ph.notChangeGrade) // T0

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

Delegates.notNull 非空屬性委托

我們也可以使用委托來實現(xiàn)屬性的非空限制：

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 mapval 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 mapvar 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)

本章小結(jié)

本章我們介紹了Kotlin面向?qū)ο缶幊痰奶匦?#xff1a; 類與構(gòu)造函數(shù)、抽象類與接口、繼承以及多重繼承等基礎知識，同時介紹了Kotlin中的注解類、枚舉類、數(shù)據(jù)類、密封類、嵌套類、內(nèi)部類、匿名內(nèi)部類等特性類。最后我們學習了Kotlin中對單例模式、委托模式的語言層面上的內(nèi)置支持：object對象、委托。

總的來說，Kotlin相比于Java的面向?qū)ο缶幊?#xff0c;增加不少有趣的功能與特性支持，這使得我們代碼寫起來更加方便快捷了。

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

本章示例代碼工程：

https://github.com/EasyKotlin...

總結(jié)

以上是生活随笔為你收集整理的《Kotin 极简教程》第7章 面向对象编程（OOP）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。