前言
因為工作需要，所以最近大量的時間都用在了對Kotlin的提升上。所以最近的文章基本都是關於Kotlin的了內容。
這不是一個死扣細節的文章，而是一個幫助小夥伴們快速由Java（Android）轉向Kotlin的文章，因此更多的是一種語法與思想混在的模式。
正文
不多扯淡，點進來的小夥伴們肯定都是來學技術的，開搞。
一、屬性
各位，千萬不要因為標題的屬性，就覺得沒什麼營養，以為我要說什麼var、val。不不不，往下看，kotlin中的屬性大有文章。
1.1、可觀察屬性Observable
這個語言特性，是非常非常用意思，且實用的。不信？往下看，來一個demo：
classUser{var name: String by Delegates.observable("") {prop, old, new -> println("$old -> $new") }}funmain() {val user = User() user.name = "first" user.name = "second"}
效果好不好，咱們看「療效」，運行結果如下：
是不是覺得有點意思？我們name這個屬性的任何變化，都被觀察了。我們可以在回調函數中，「胡搞瞎搞」~至於怎麼搞？whatever。有小夥伴可能想說，既然我監聽了屬性的變化，我可以不以偷偷改些屬性呢？當然可以，不過我們需要下面這個函數。
1.2、vetoable
vetoable比較有意思，可以理解為一個hook函數，它接受一個用於判斷的表達式，滿足這個表達式的才會被賦值，否則丟棄。很簡單，上demo：
// 過濾不滿足條件的setvar max: Intby Delegates.vetoable(0) { property, oldValue, newValue ->newValue > oldValue}println(max) // 0max = 10println(max) // 10max = 5println(max) // 10
2.1、延遲屬性 Lazy
官方解釋（羅裡吧嗦，不看也罷）lazy() 是接受一個 lambda 並返回一個 Lazy
說白了就是懶加載。被lazy標識的變量，在被調用的時候會觸發我們實現的表達式,
（下文會重點聊表達式，這裡我們只需要之後，表達式的最後一行，代表著return）
並拿到表達式的返回值。但表達式只會執行一次，後續的調用，直接回去表達式的返回值。也就是我們常說的懶加載。
val lazyValue: String by lazy {println("computed!")"Hello"}funmain() { println(lazyValue) println(lazyValue)}
看結果我們就很清晰了吧。
委託
上邊說的這些東西，在Kotlin之中都統一稱之為委託/委託屬性。委託是比較好用的一種語言特性，甚至可以很巧妙的幫我們解決一些複雜的設計模式上的問題。這其中的有趣，還望小夥伴們自己去探索呦~
二、表達式
對於我的學習來說，表達式的不理解，最開始對我閱讀代碼造成了很大的困惑。主要是少了「相濡以沫」的return，搞得自己有點懵。所以這裡，讓我們聊一聊表達式，也算填了上文挖的坑。
1.1、if表達式
if這個關鍵字，在Kotlin中代表一個表達式，它會默認有一個return，就是表達式中的最後一行。比如：
var num = if(...某個判斷){666}else{66666}
這裡num的值就是666。既然我們的if有自帶return的功能，那麼我們Java中常用的?:（三元運算符）是不是就沒辦法用了？的確要三元運算符（條件 ? 然後 : 否則）在Kotlin中換了寫法（但並非不能用），因為普通的 if 就能勝任這個角色。
// 作為表達式val max = if (a > b) a else bval max = if (a > b) {print("Choose a") a} else { print("Choose b") b}
?:在Kotlin中表示： 如果左側的值為空，就取右側的值。
更多有趣的符號用法，可以參考官網：https://www.kotlincn.net/docs/reference/keyword-reference.html
1.2、關於return
既然我們從if中，了解了if中的隱式return，那這裡可能會有一個疑問，能不能顯示的寫一個return呢？答案是：不行。因為在Kotlin中，return的語義是這樣的：從最直接包圍它的函數或者匿名函數返回。
表示式不屬於函數，所以不行，同樣Lambda表達式也不行。不這裡有些特殊情況，所以我們好好聊一聊：
要退出一個 Lambda 表達式，我們必須使用一個標籤，並且在 Lambda 表達式內部禁止使用裸 return，因為 Lambda 表達式不能使包含它的函數返回：
// 這裡forEach是一個Lambda表達式，我們使用**標籤**的形式，使其returnlistOf(1, 2, 3, 4, 5).forEach lit@{if (it == 3) return@lit// 局部返回到該 lambda 表達式的調用者，即 forEach 循環print(it)}
這裡肯定有小夥伴質疑：我可以在forEach裡直接return啊！沒錯，的確是可以。因為forEach內聯函數。內聯函數是可以return的：
關於內聯函數後文會有篇幅展開它。
官方介紹：內聯是被允許的(這種返回（位於 lambda 表達式中，但退出包含它的函數）稱為非局部返回。)
inlinefuninlined(block: () -> Unit) {println("hi!")}funfoo() { inlined {return// OK：該 lambda 表達式是內聯的 }}funmain() { foo()}
比如，這種return是合法的，因為foreach是內聯函數
fun hasZeros(ints: List): Boolean {ints.forEach { if (it == 0) return true // 從 hasZeros 返回 } return false}public inline fun Iterable.forEach(action: (T) -> Unit): Unit { for (element in this) action(element)}
嘚吧嘚說了這麼，日常能用到麼？說實話，沒有diao用。不過，遇到了咱們知道該如何解釋，這也算是一種收穫吧。
2.1、When 表達式
when是我們常用的switch的增強plus版。其最簡單的形式如下：
when (x) {1 -> print("x == 1")2 -> print("x == 2")else -> { // 注意這個塊print("x is neither 1 nor 2") }}
我們也可以檢測一個值在（in）或者不在（!in）一個區間或者集合中。即滿足某些條件：
when (x) {in1..10 -> print("x is in the range")in validNumbers -> print("x is valid")!in10..20 -> print("x is outside the range")else -> print("none of the above")}
另一種用法是檢測一個值是（is）或者不是（!is）一個特定類型的值。
由於智能轉換，我們可以訪問該類型的方法與屬性而無需任何額外的檢測。
funhasPrefix(x: Any) = when(x) {is String -> x.startsWith("prefix")else -> false}
因為，說when是switch的plus不為過吧。更多有趣的用法，歡迎各位小夥伴留言補充呦~
三、雜亂的小細節
1.1、Class
val c = MyClass::class
返回的是KClass，如果我們需要Class，則要這樣
MyClass::class.java
1.2、this
要訪問來自外部作用域的this（一個類 或者擴展函數， 或者帶標籤的帶有接收者的函數字面值）我們使用this@label，其中 @label 是一個代指 this 來源的標籤：
classA{ // 隱式標籤 @Ainner classB{ // 隱式標籤 @BfunInt.foo() { // 隱式標籤 @fooval a = this@A// A 的 thisval b = this@B// B 的 thisval c = this// foo() 的接收者，一個 Intval c1 = this@foo// foo() 的接收者，一個 Intval funLit = lambda@fun String.() {val d = this// funLit 的接收者 }val funLit2 = { s: String ->// foo() 的接收者，因為它包含的 lambda 表達式// 沒有任何接收者val d1 = this } } }}
1.3、匿名函數
var list = arrayListOf(1, 2, 3, 4, 5, 6)// lambda表達式list.filter { it > 3 }// 規規矩矩的匿名函數 list.filter(fun(it): Boolean {return it > 3 })// 自動類型推斷後簡寫的匿名函數 list.filter(fun(it) = it > 3)
對於具有表達式函數體的匿名函數將自動推斷返回類型，而具有代碼塊函數體的返回類型必須顯式指定（或者已假定為 Unit）匿名函數參數總是在括號內傳遞。 允許將函數留在圓括號外的簡寫語法僅適用於 lambda 表達式。
Lambda表達式與匿名函數之間的另一個區別是非局部返回的行為。一個不帶標籤的 return 語句總是在用 fun 關鍵字聲明的函數中返回。這意味著 lambda 表達式中的 return 將從包含它的函數返回，而匿名函數中的 return 將從匿名函數自身返回。
1.4、內聯函數
使用高階函數（關於高階函數，可以看我之前的一篇文章）會帶來一些運行時的效率損失。因為每一個函數都是一個對象，並且會捕獲一個閉包（ 即那些在函數體內會訪問到的變量）。 我們都清楚，內存分配（對於函數對象和類）和虛擬調用會引入運行時的開銷。所以此時就需要內聯函數，來消除這種開銷。官方使用了lock這個函數來解釋這個問題：
funlock(lock: Lock, body: () -> T): T {lock.lock()try {return body() }finally { lock.unlock() }}
正常我們會這樣調用這個函數
lock(l) { foo() }
。如果不加修飾的話，因為高階函數的存在，會造成大量的對象對創建出來，所以我們這裡我們需要用內聯的方式消除這種額外。
// 使用內聯，代碼編譯後將變成這樣l.lock()try {foo()}finally { l.unlock()}
可能有小夥伴在這裡會有一些懵逼，一時沒有理解內聯做了什麼。接下來用三個函數，解釋一下這個問題：
// 一個函數中，調用了另一個函數。虛擬機勢必要為funtion1的調用，增加很多開銷。funfuntion(){var a =1+1+1funtion1()}funfuntion1(){var aa =1+1+1var bb =1+1+1var cc =1+1+1}// 那麼我們使用內聯之後，就變成了這樣：funfuntion(){var a =1+1+1var aa =1+1+1var bb =1+1+1var cc =1+1+1}
我們可以看到，內聯之後，我們funtion1函數中的實現，仿佛就在funtion函數中一樣。因此就相應的降低了這部分的消耗。
內聯可能導致生成的代碼增加；不過如果我們使用得當（即避免內聯過大函數），性能上會有所提升，尤其是在循環中的「超多態（megamorphic）」調用處。
尾聲
OK，到此差不多關於Kotlin的基於語法的內容差不多就要告一段落了。接下來的文章基本就會圍繞著Android中的Kotlin進行開展。希望各位小夥伴們可以從中有所收穫呦~