Kotlin 基礎(chǔ)知識
一，Using Kotlin for Android Development
? 1.1 使用Kotlin做Android開發(fā)
Kotlin 是非常適合用于開發(fā)Android應(yīng)用的，它給Android平臺帶來了新語言的所有優(yōu)點卻不增加任何新的限制：
兼容性：Kotlin完全兼容JDK6，所以Kotlin可以在老舊的Android設(shè)備上運行不出問題。AndroidStudio完全支持Kotlin，編譯系統(tǒng)也兼容Kotlin。
性能：因為非常相似的字節(jié)碼結(jié)構(gòu)，Kotlin應(yīng)用運行速度和Java一樣快。因為Kotlin支持內(nèi)聯(lián)函數(shù)，當時用lambdas時，通常比用Java代碼運行更快。
互通性：Kotlin能100%與Java相互協(xié)作，能使用所有的Android庫，包括注解處理庫，所以像databinding，dagger這些庫都能使用。
占用空間：Kotlin的運行時庫非常簡潔，當時用混淆的時候還會縮減到更小，只會增加幾百個方法，只增加apk不到100k的體積。
編譯時間：Kotlin支持高效的增量編譯，所以當項目已經(jīng)編譯過，再進行額外的編譯時，這種增量編譯可以像Java一樣快，甚至更快。
學習曲線：對于Java開發(fā)者來說，使用Kotlin非常簡單。Java代碼自動化轉(zhuǎn)換成Kotllin代碼的Kotlin插件幫我們邁出了第一步。 Kotlin Koans 通過一系列的包含Kotlin主要特點的交互性習題給我們提供了指南。
1.2 用Kotlin 做Android開發(fā)樣例研究
Kotlin已經(jīng)被一些大企業(yè)接受，其中部分企業(yè)分享了他們的經(jīng)驗：
Pinterest已經(jīng)成功地在他們月用戶量1.5億的應(yīng)用中引進了Kotlin。
Basecamp 的Android app 100%使用Kotlin代碼，他們表示Kotlin給他們帶來了編程的快樂，以及工作質(zhì)量和效率的提升。
Keepsafe的app Lock app也已經(jīng)轉(zhuǎn)換成100%的Kotlin，這使得代碼行數(shù)減少30%，方法數(shù)減少10%。
1.3 Android 開發(fā)工具
Kotlin團隊一套工具用于開發(fā)，其中有超越了標準語言的特性：
是編譯器的拓展，它使你免去在代碼中調(diào)用findViewById()方法，而是通過編譯生成。
Anko是一個庫，它提供了一組Android APIs和DSL的包裝，讓你用Kotlin代碼替換.xml文件。
1.4 下一步
下載安裝 Android Studio 3.0，它提供了Kotlin支持，安裝即可使用。
按照 Getting Started with Android and Kotlin指導(dǎo)創(chuàng)建你的第一個Kotlin應(yīng)用。
想要深入了解，可查看reference documen和Kotlin Koans。
另一個很好的資源是一本書《 Kotlin for Android Developers》，它一步一步地指導(dǎo)你創(chuàng)建一個Kotlin編寫的Android應(yīng)用。
看Google的樣例 sample projects written in Kotlin。
二，變量的聲明和使用
2.1 變量聲明
只讀變量
可理解為Java中常量，使用 val 關(guān)鍵字修飾
val a: Int = 1? //在聲明的時候直接賦值
val b = 2? // 類型是明確的，變量類型Int可省去
val c: Int? // 在聲明時沒有賦值，變量類型Int不可省去
c = 3? ? ? // 只可賦值一次，此后c值不能再變
易變變量
可理解為Java中的普通變量，用 var 關(guān)鍵字修飾，與 val 變量的區(qū)別是變量的值可變：
var a=0
a=1
a=3
成員變量
與Java一樣，通過對象.變量名的方式調(diào)用：
fun main(args: Array<String>) {
? ? print(Test().property)
}
class Test{
? ? var property="property"
}
靜態(tài)變量
用companion object{}包裹，與Java一樣通過類名.變量名的方式調(diào)用，關(guān)于companion object后面會詳細講解：
fun main(args: Array<String>) {
? ? print(Test.com)
}
class Test{
? ? companion object{
? ? ? ? var com="com"
? ? }
}
頂級變量
在類的外部聲明，可理解為Java中的靜態(tài)成員變量。
通過包名.變量名的方式來調(diào)用
樣例：
package a.b.c
var top = "top"
fun main(args: Array<String>) {
? ? print(a.b.c.top)
}
靜態(tài)變量與頂級變量的區(qū)別：
通過反編譯可以知道，其實他們不在一個類中。
當文件中有頂級變量，編譯時會新生成一個[文件名+kt]的類，頂級變量就在其中。
2.2 Getters and Setters
我們先定義各種可見性的var類型成員變量：
? ? private var privateField = ""
? ? internal var internalField = ""
? ? protected var protectedField = ""
? ? var publicField = ""
然后反編譯看看對應(yīng)的java代碼：
? @NotNull
? public final String getInternalField$app() {
? ? ? return this.internalField;
? }
? public final void setInternalField$app(@NotNull String var1) {
? ? ? Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
? ? ? this.internalField = var1;
? }
? @NotNull
? protected final String getProtectedField() {
? ? ? return this.protectedField;
? }
? protected final void setProtectedField(@NotNull String var1) {
? ? ? Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
? ? ? this.protectedField = var1;
? }
? @NotNull
? public final String getPublicField() {
? ? ? return this.publicField;
? }
? public final void setPublicField(@NotNull String var1) {
? ? ? Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
? ? ? this.publicField = var1;
? }
可知，protected和public會生成對應(yīng)的setter和getter方法，internal也生成了特殊的對應(yīng)方法。
所以對于protected和public的成員變量，我們不能自己創(chuàng)建對應(yīng)的getter和setter方法，如：
var name:String?
fun setName(name:String){}
將會報錯：
Platform declaration clash: The following declarations have the same JVM signature (setName(Ljava/lang/String;)V)
Visibility Modifiers
對于getter
getter的可見性和變量的可見性相同，無需重復(fù)添加修飾符。非要多此一舉添加，如果和變量的修飾符不一樣，將會報錯，如：
var field: String = ""
private get? //報錯： Getter visibility must be the same as property visibility
對于setter
setter的可見性必須小于等于變量自身的可見性，否則報錯，如：
private var name=""
public set //error：Setter visibility must be the same or less permissive than property visibility
我們也可以自定義getter和setter方法
語法
<var <propertyName>[: <PropertyType>] [= <property_initializer>]
? ? [<getter>]
? ? [<setter>]
當給變量賦值時會調(diào)用setter方法，調(diào)用變量得到的是getter中的返回值
樣例：
var name: String = "111"
? ? get() {
? ? ? ? return "{$field}"
? ? }
? ? set(value) {
? ? ? ? field = "[$value]"
? ? }
fun main(args: Array<String>) {
? ? println(name)
? ? name = "222"
? ? print(name)
}
結(jié)果：
{111}
{[222]}
三，方法的定義和使用
3.1 方法定義
定義語法：
fun? [方法名] ( [參數(shù)名] : [參數(shù)類型] ) : [返回類型]{
? ? ...
? ? return [返回值]
}
有返回值
fun multiply(x: Int, y:Int): Int {
? ? return x * y
}
也可以轉(zhuǎn)換為：
fun multiply(x: Int, y: Int): Int = x * y
還可以這樣：
var multiply = { x: Int, y: Int -> x * y }
無返回值
使用Unit代替返回類型：
fun log(msg: String): Unit {
? ? print(msg)
}
Unit也可以省去：
fun log(msg: String) {
? ? print(msg)
}
成員方法
與Java一樣通過對象.方法名的方式調(diào)用：
fun main(args: Array<String>) {
? ? Test().method()
}
class Test{
? ? fun method(){
? ? ? ? print("hello")
? ? }
}
靜態(tài)方法
和Java一樣通過類名.方法名的方式調(diào)用：
fun main(args: Array<String>) {
? ? Test.com()
}
class Test{
? ? companion object{
? ? ? ? fun com(){
? ? ? ? ? ? print("com")
? ? ? ? }
? ? }
}
頂級方法
在類外部定義的方法，可理解為靜態(tài)方法，通過包名.方法名的方式調(diào)用：
package a.b.c
fun top(){
? ? print("top")
}
fun main(args: Array<String>) {
? ? a.b.c.top()
}
頂級方法與靜態(tài)方法區(qū)別
通過反編譯可以知道，其實他們不在一個類中。
如果有頂級變量會新生成一個[文件名+kt]的類，頂級方法就在其中。
3.2 方法調(diào)用順序可變
通過指明參數(shù)名稱，可按任意順序傳參：
fun main(args: Array<String>) {
? ? log(name = "mao", age = 18)
}
fun log(age: Int, name: String) {
? ? print("age:$age,name:$name")
}
3.3 命名參數(shù)
方法樣例：
fun logInfo(
? ? ? ? name: String,
? ? ? ? age: Int,
? ? ? ? married: Boolean = true,
? ? ? ? language: String = "Chinese"
) {
? ? println("[name:$name,age:$age,married:$married,language:$language");
}
必須傳入未設(shè)置默認值的參數(shù)
在上述logInfo方法中，name和age未設(shè)置默認值，必須傳參，其它參數(shù)可自由選擇：
? ? logInfo("ma",18)
? ? logInfo("ma",18,false);
? ? logInfo("ma",18,false,"English");
3.4 可變參數(shù)
使用vararg 修飾參數(shù)：
fun logInfos(vararg infos: String) {
? ? for (info in infos) {
? ? ? ? print("$info? ")
? ? }
}
方法調(diào)用
logInfos("aaa","bbb","ccc")
四，null安全(“?”，“?:”，“!!”)
在Java開發(fā)中，null一直是個大問題，哪怕我們再小心，也難免有疏忽的時候，Kotlin針對這個問題做了一些措施。
Kotlin將變量分為可以為Nullable類型 Non-Null類型，變量在聲明時就要確定屬于哪個陣營。
變量默認Non-Null類型，如果想聲明Nullable的變量，需要用“?”修飾：
聲明Non-Null變量
? ? var a: String = "hello"?
聲明Nullable變量
? ? var b: String? = "world"
聲明變量時若直接賦值，變量類型由所賦值的類型決定
如在聲明b時，將a賦值給b，b的類型（Nullable或Non-Null）與a相同：
? ? var a: String? = "hello"? //Nullable
? ? var b = a? //與a相同，也是Nullable
4.1 Non-Null變量賦值
Non-Null變量不能賦值為null
var a: String=null //報錯：Null can not be a value of a non-null type String
Nullable變量無法直接賦值給Non-Null變量
? ? var a: String? = "hello"
? ? var b = "world"
? ? b = a //報錯：Type mismatch: inferred type is String? but String was expected
想要將Nullable變量賦值給Non-Null變量有以下方法：
先處理后賦值
? ? var a: String? = "hello"
? ? var b = "world"
? ? if (a != null) {
? ? ? ? b == a
? ? }
使用“!!”
? ? var a: String? = "hello"
? ? var b = "world"
? ? b = a!!
使用“!!”方法要注意，當a為null時會拋出KotlinNullPointerException異常。
4.2 Nullable變量的使用
“?”符號的使用
Nullable變量進行操作時要帶“?”，當變量為null時，不會出現(xiàn)異常，而是返回結(jié)果null：
? ? var name: String? = null
? ? var len = name?.length
? ? print(len == null)? //輸出：true
“?:”符號的使用
這個符號的作用是當它左邊的結(jié)果為null時，進行右邊的操作。
左邊結(jié)果不為null：
? ? var a: String? = "hello"
? ? var b = a?.length ?: 100? //很明顯左邊不為null
? ? println(b)? //輸出： 5
左邊結(jié)果為null：
? ? var a: String? = null
? ? var b = a?.length ?: 100? //左邊為null，返回右邊的100
? ? println(b)? //輸出： 100
五，類與繼承
5.1 類的創(chuàng)建
與Java一樣，Kotlin也是用class關(guān)鍵字聲明類。
class User{}
Kotlin中一個類可以有一個主構(gòu)造方法（primary constructor）和一個或多個次構(gòu)造方法（ secondary constructors）。
5.2 主構(gòu)造方法
主構(gòu)造方法通過在類名后面添加constructor和參數(shù)實現(xiàn)：
class User private constructor(name: String) {}
如果沒有注解和可見的修飾符，constructor關(guān)鍵字可以省略：
class User(name: String) {}
初始化順序
類內(nèi)部的init模塊和變量的初始化順序按照他們出現(xiàn)的順序進行
fun main(args: Array<String>) {
? ? User("mao")
}
class User(name: String) {
? ? val firstProperty = "First property".also(::println)
? ? init {
? ? ? ? println("First initializer")
? ? }
? ? val secondProperty = "Second property".also(::println)
? ? init {
? ? ? ? println("Second initializer")
? ? }
}
輸出：
First property
First initializer
Second property
Second initializer
成員變量和init模塊在初始化時可直接使用主構(gòu)造方法中的參數(shù)
class User(name: String) {
? ? var mName = name
? ? init {
? ? ? ? var mName = name
? ? }
}
5.3 次構(gòu)造方法
次構(gòu)造方法也使用constructor實現(xiàn)
class User {
? ? var name: String = ""
? ? constructor(name: String) {
? ? ? ? this.name = name
? ? }
}
當類聲明了主構(gòu)造方法，所有次構(gòu)造方法必須直接或間接調(diào)用主構(gòu)造方法
class User() {
? ? constructor(name: String) : this() {
? ? ? ? print("conconstructor")
? ? }
? ? constructor(name: String, age: Int) : this(name) {}
}
類中的變量初始化和init模塊初始化都是主構(gòu)造方法的一部分，所以都在次構(gòu)造方法之前執(zhí)行
fun main(args: Array<String>) {
? ? User("mao")
}
class User() {
? ? constructor(name: String) : this() {
? ? ? ? print("conconstructor")
? ? }
? ? var name = "property".also(::println)
? ? init{
? ? ? ? println("init")
? ? }
}
輸出：
property
init
conconstructor
當一個類沒有任何構(gòu)造方法時，默認生成一個public類型的無參主構(gòu)造方法，如果不希望這個默認構(gòu)造方法存在，可以主動聲明一個主構(gòu)造方法
class User private constructor() {}
5.4 繼承
Kotlin中的類默認是final類型的，想要被繼承，得用“open”關(guān)鍵字修飾。
open class Shape {}
class Rectangle : Shape {}
子類的所有構(gòu)造構(gòu)造方法必須直接或間接調(diào)用一個父類的構(gòu)造方法
open class Shape {
? ? constructor(name: String) {
? ? ? ? print(name)
? ? }
}
class Rectangle : Shape {
? ? constructor(name: String) : super(name) {}
? ? constructor(name: String, age: Int) : this(name) {}
}
方法重寫
繼承過程中，只有open修飾的方法才能被重寫，重寫時要用override修飾。
open特性也能被繼承，想要斷了open特性，只需用final修飾即可。
open class Shape {
? ? open fun method() {}
}
open class Rectangle : Shape() {
? ? override fun method() {}
}
class Square : Rectangle() {
? ? final override fun method() {}
}
成員變量重寫
與方法重寫相同，只有open修飾的變量才能被重寫，open同樣可以繼承，也可以用final中斷。
重寫過程中，變量可由val類型變?yōu)関ar類型，反之則不行。
open class Shape {
? ? open val name: String = "Shape"
}
open class Rectangle : Shape() {
? ? override var name: String = "Rectangle"
}
class Square : Rectangle() {
? ? final override var name = "Square"
}
調(diào)用父類方法和成員變量
可通過“super”關(guān)鍵字調(diào)用父類的方法和成員變量
open class Shape {
? ? open val name: String = "Shape"
? ? open fun draw() {}
}
open class Rectangle : Shape() {
? ? override var name: String = super.name
? ? override fun draw() {
? ? ? ? super.draw()
? ? }
}
內(nèi)部類調(diào)用外部類父類的方法
使用“super@Outer”方式：
open class Sup {
? ? open fun method() { println("Sup.method") }
}
class Sub:Sup(){
? ? inner class Inner{
? ? ? ? fun test(){
? ? ? ? ? ? super@Sub.method()
? ? ? ? }
? ? }
}
當繼承的類和接口當中出現(xiàn)相同的方法（方法名和參數(shù)都相同），通過類似泛型的方法明確調(diào)用哪個方法
interface Action {
? ? fun eat() {
? ? ? ? println("Action")
? ? }
}
open class Animal {
? ? open fun eat() {
? ? ? ? println("Animal")
? ? }
}
class Human() : Animal(), Action {
? ? override fun eat() {
? ? ? ? super<Action>.eat()
? ? ? ? super<Animal>.eat()
? ? }
}
六，內(nèi)聯(lián)方法
使用高階方法會造成一些強制性的開銷：內(nèi)存分配和調(diào)用都是開銷。不過，在許多情況下有些開銷是可以避免的。
例子：
現(xiàn)在把吃飯分為三個步驟：1.拿起筷子 2.吃 一口3.放下筷子
1.情況一：每吃一口都要放下筷子，即拿、吃、放、拿、吃、放...
操作順序：
1、2、3;? 1、2、3; 1、2、3...
這種情況不是飯菜不合胃口、就是吃撐了。
2.情況二：每吃若干口才放下筷子。
操作順序：
1、2、2...2、3; 1、2、2...2、3;... 1、2、2...2、3;
明顯這才是正確操作，能省不少力氣。
在JVM中也有類似的情況，JVM中每個線程都有一個虛擬機棧，每個方法的從調(diào)用到完成，對應(yīng)著入棧、出棧的過程，如果將一方法分為多個方法時，就會有更多的入棧、出棧的開銷，使用內(nèi)聯(lián)方法能有效減少這部分開銷。
例一
現(xiàn)在我們要打印一個人，分三部分打?。侯^、身體和腳，其中身體構(gòu)造復(fù)雜，又要分三部分
1-1
fun main(args: Array<String>) {
? ? //printHead
? ? println("head")
? ? //printbody
? ? println("body1")
? ? println("body2")
? ? println("body3")
? ? //printFoot
? ? println("foot")
}
現(xiàn)在我們想把打印身體這部放到一個單獨的方法中，使代碼更清晰：
1-2
fun main(args: Array<String>) {
? ? //printHead
? ? println("head")
? ? //printbody
? ? printBody()
? ? //printFoot
? ? println("foot")
}
fun printBody() {
? ? println("body1")
? ? println("body2")
? ? println("body3")
}
不過這樣一來多了部分開銷，這時內(nèi)聯(lián)方法可以幫我們避免這部分開銷。
6.1 inline
定義內(nèi)聯(lián)方法需使用“inline”關(guān)鍵字修飾
1-3
fun main(args: Array<String>) {
? ? //printHead
? ? println("head")
? ? //printbody
? ? printBody()
? ? //printFoot
? ? println("foot")
}
inline fun printBody() {
? ? println("body1")
? ? println("body2")
? ? println("body3")
}
編譯過程會幫我們把1-3轉(zhuǎn)換為1-1的樣子，提高了性能的同事又能保證結(jié)構(gòu)清晰。
例二
如何才能將代碼
lock(l) { foo() }
實現(xiàn)這樣的效果：
l.lock()
try {
? ? foo()
}
finally {
? ? l.unlock()
}
可以通過內(nèi)聯(lián)方法實現(xiàn)：
inline fun <T> check(lock: Lock, body: () -> T): T {
? ? lock.lock()
? ? try {
? ? ? ? return body()
? ? } finally {
? ? ? ? lock.unlock()
? ? }
}
調(diào)用：
? ? var lock = ReentrantLock()
? ? check(lock) {print("hello")}
完整樣例：
開啟兩個線程，通過加同一把鎖實現(xiàn)同步：
fun main(args: Array<String>) {
? ? var lock = ReentrantLock()
? ? Thread() {
? ? ? ? check(lock) {
? ? ? ? ? ? for (i in 1..5) {
? ? ? ? ? ? ? ? TimeUnit.SECONDS.sleep(1)
? ? ? ? ? ? ? ? println("111")
? ? ? ? ? ? }
? ? ? ? }
? ? }.start()
? ? Thread() {
? ? ? ? check(lock) {
? ? ? ? ? ? for (i in 1..5) {
? ? ? ? ? ? ? ? TimeUnit.SECONDS.sleep(1)
? ? ? ? ? ? ? ? println("222")
? ? ? ? ? ? }
? ? ? ? }
? ? }.start()
}
inline fun <T> check(lock: Lock, body: () -> T): T {
? ? lock.lock()
? ? try {
? ? ? ? return body()
? ? } finally {
? ? ? ? lock.unlock()
? ? }
}
輸出：
111
111
111
111
111
222
222
222
222
222
6.2 noinline
inline 方法中的方法參數(shù)默認是inline類型的，如果想過濾掉inline特性，可用noinline修飾。
inline fun foo(inlined: () -> Unit, noinline notInlined: () -> Unit) {
? ? // ...
}
6.3 lambda與return
1.普通方法的lambda模塊中禁止使用return
fun foo() {
? ? ordinaryFunction {
? ? ? ? return // ERROR: can not make `foo` return here
? ? }
}
2.inline方法的lambda模塊可用使用return
fun foo() {
? ? inlineFunction {
? ? ? ? return // OK: the lambda is inlined
? ? }
}
fun hasZeros(ints: List<Int>): Boolean {
? ? ints.forEach {
? ? ? ? if (it == 0) return true // returns from hasZeros
? ? }
? ? return false
}
這么設(shè)計很好理解，普通方法的lambda模塊其實是另一個方法的方法體，你在本方法中調(diào)用另一方法中的return算是怎么回事，稍不注意容易理解錯誤。
而inline方法可認為是本方法的一部分，外面那層大括號包裝可當它不存在，使用return就顯得和自然了。
3.那么想要在普通方法lambda return怎么辦？只需在return后加“@方法名”即可：
fun f() {
? ? test {
? ? ? ? return@test
? ? }
}
fun test(action: () -> Unit) {}
4.inline 類型的方法參數(shù)不能直接用于賦值，要想用于賦值得用crossinline 修飾
inline fun f(crossinline body: () -> Unit) {
? ? val f = object: Runnable {
? ? ? ? override fun run() = body()
? ? }
}
6.4 reified
泛型只在編譯時起作用，在運行時已經(jīng)被擦除，所以泛型標記是沒法當做對象使用的。
不過在Kotlin中，reified可修飾inline方法中的泛型，對其進行反射操作。
inline fun <reified T> membersOf() = T::class.members
fun main(s: Array<String>) {
? ? println(membersOf<User>())
}
class User() {
? ? var name = "mao"
}
七，enum，data，sealed，object
7.1 enum類
7.1.1與java不同，Kotlin中enum當做class的修飾符使用
1.常見用法：
enum class Direction {
? ? NORTH, SOUTH, WEST, EAST
}
2.有成員屬性時：
enum class Color(val rgb: Int) {
? ? RED(0xFF0000),
? ? GREEN(0x00FF00),
? ? BLUE(0x0000FF)
}
打印成員的值
print(Color.RED.rgb)
3.匿名方法
假如有一個機器，他有三種狀態(tài)start，run，stop，并且不斷循環(huán)我們可以這樣實現(xiàn)：
enum class State {
? ? Start {
? ? ? ? override fun nextState() = Run
? ? },
? ? Run {
? ? ? ? override fun nextState() = Stop
? ? },
? ? Stop {
? ? ? ? override fun nextState() = Start
? ? };
? ? abstract fun nextState(): State
}
簡單調(diào)用：
fun main(args: Array<String>) {
? ? var state = State.Stop
? ? println(state)
? ? for (i in 1..3) {
? ? ? ? state = state.nextState()
? ? ? ? println(state)
? ? }
}
輸出：
Stop
Start
Run
Stop
7.2 data類
在Java中，我們在信息類創(chuàng)建信息類時總是伴隨大量getter/setter方法，雖然可以用工具自動生成，但也影響美觀。Kotlin中使用data類型幫助我們解決了這個問題。
data class User(
? ? ? ? var name: String,
? ? ? ? var age: Int
)
在編譯時，根據(jù)主構(gòu)造器中的參數(shù)會自動生成getter/setter，hashcode()，toString()，equals()，copy()等方法。
我們無法直接調(diào)用getter/setter 方法，但我們對它的操作上本質(zhì)上都是通過調(diào)用getter/setter方法實現(xiàn)的。
data class User(
? ? ? ? var name: String,
? ? ? ? var age: Int
)
設(shè)置和修改變量的值
? ? var user = User("mao", 18)
? ? user.name = "zhang"
? ? user.age = 3
copy()
當我們想將對象復(fù)制一份時,可用copy()方法：
? ? var user = User("mao", 18)
? ? var user2 = user.copy()
如果想改變某個變量：
? ? var user=User("mao",18)
? ? var user2=user.copy(age=100)
7.3 sealed類
sealed類可看做時enum類的一種拓展，相比于enum的常量以單一實例存在，sealed類的子類可以有多種確定的類型。
sealed類自身是抽象類，它的子類不能是抽象類，子類和它必須在同一個文件中。
sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()
與when搭配使用非常方便
fun eval(expr: Expr): Double = when(expr) {
? ? is Const -> expr.number
? ? is Sum -> eval(expr.e1) + eval(expr.e2)
? ? NotANumber -> Double.NaN
}
栗子：現(xiàn)在將人根據(jù)顏值和智商分為4類：
1.有顏值有智商
2.有顏值沒智商
3.沒智商有顏值
4.沒智商沒顏值
sealed class Feature
data class IQ(var score: Int) : Feature()
data class FaceScore(var Sore: Int) : Feature()
data class Sum(var f1: Feature, var f2: Feature) : Feature()
object None : Feature()
然后設(shè)計評分機制:顏值（faceScore）和智商（IQ）基礎(chǔ)分0-10分
sum(總分)= faceScore * 8 + IQ * 2
計算方法實現(xiàn)：
fun cal(f: Feature): Int = when (f) {
? ? is IQ -> {
? ? ? ? f.score * 2
? ? }
? ? is FaceScore -> f.Sore * 8
? ? is Sum -> cal(f.f1) + cal(f.f2)
? ? None -> 0
}
計算：
fun main(args: Array<String>) {
? ? var f1 = IQ(10)
? ? var f2 = FaceScore(10)
? ? var f3 = Sum(f1, f2)
? ? var f4=None
? ? cal(f1).also(::println)
? ? cal(f2).also(::println)
? ? cal(f3).also(::println)
? ? cal(f4).also(::println)
}
7.4 object
object到底有什么作用呢？先創(chuàng)建一個最簡單的object類
用來實現(xiàn)單例模式
object O
反編譯獲得Java代碼：
public final class O {
? ? public static final O INSTANCE;
? ? static {
? ? ? ? O localo = new O();
? ? ? ? INSTANCE = localo;
? ? }
}
這是一種單例模式的實現(xiàn)方法，如此看來object 可以用來實現(xiàn)單例模式。
簡單用法：
fun main(args: Array<String>) {
? ? O.test()
? ? O.name = "hello"
}
object O {
? ? var name = "mao"
? ? fun test() {
? ? ? ? print("test")
? ? }
}
object還可以用來實現(xiàn)匿名內(nèi)部類
fun main(args: Array<String>) {
? ? var btn = Btn()
? ? btn.onClickLsn = object : Btn.OnClickLsn {
? ? ? ? override fun click() {
? ? ? ? ? ? print("click")
? ? ? ? }
? ? }
? ? btn.callClick()
}
class Btn() {
? ? var onClickLsn: OnClickLsn? = null
? ? fun callClick() {
? ? ? ? onClickLsn?.click()
? ? }
? ? interface OnClickLsn {
? ? ? ? fun click()
? ? }
}
object類可以繼承一個類和多個接口。
當父類有構(gòu)造方法時，應(yīng)傳入對應(yīng)的參數(shù)。
interface A
open class B(age: Int) {
? ? var mAge = age
}
var c: A = object : B(18), A {}
object可以做private方法和成員變量的返回值，不能做public方法和成員變量的返回值。
作為private方法和變量的返回值時，返回類型是匿名對象類型，可以訪問內(nèi)部成員。
而最為public方法和變量返回值時，返回類型為Any，不能訪問內(nèi)部成員。
class C {
? ? // private方法，返回類型是匿名對象類型
? ? private fun foo() = object {
? ? ? ? val x: String = "x"
? ? }
? ? // public方法，返回類型是 Any
? ? fun publicFoo() = object {
? ? ? ? val x: String = "x"
? ? }
? ? fun bar() {
? ? ? ? val x1 = foo().x? ? ? ? // 沒問題
? ? ? ? val x2 = publicFoo().x? //報錯，無法引用x
? ? }
}
object和companion
在類內(nèi)部，object和companion可實現(xiàn)靜態(tài)成員和靜態(tài)方法的效果。
class Outer {
? ? companion object Inner {
? ? ? ? var property = "property"
? ? ? ? fun method() {
? ? ? ? ? ? print("method")
? ? ? ? }
? ? }
}
調(diào)用：
Outer.Inner.property.also(::println)
Outer.Inner.method()
通過反編譯可知此處的 Inner并不是類，而是一個靜態(tài)常量實例。
正常使用過程中Inner可以省去：
Outer.property.also(::println)
Outer.method()
這兩種方法本質(zhì)上是一樣的。
類中的companion object修飾的Inner也可去掉：
class Outer {
? ? companion object {
? ? ? ? var property = "property"
? ? ? ? fun method() {
? ? ? ? ? ? print("method")
? ? ? ? }
? ? }
}
當沒有Inner的情況下，Inner默認為Companion
