需要說明的是，這段代碼是我從《Kotlin for Android Developer》的示例中摘出來的。有了這個Delegate類，我們就可以完全不需要關心SharedPreference了，下面給出使用的示例代碼：

class WhateverActivity : Activity(){
    var aInt: Int by Preference(this, "aInt", 0)
    
    fun whatever(){
        println(aInt)//會從SharedPreference取這個數據
        aInt = 9 //會將這個數據寫入SharedPreference
    }
}

于是我們再也不需要重復寫那些getSharedPreference，也不用edit、commit，再見那些edit之后忘了commit的日子。有沒有覺得非常贊！

擴展類，就是在現有類的基礎上，添加一些屬性或者方法，當然擴展的這些成員需要導入當前擴展成員所在的包才可以訪問到。下面給出一個例子：

data class Coordinate(val x: Double, val y: Double)

val Coordinate.theta: Double
    get() {
        return Math.atan(y/x)
    }

fun Coordinate.R():Double{
    return Math.hypot(x, y)
}

我們已經介紹過data class，Coordinate有兩個成員分別是x和y，我們知道通常表示一個二維平面，有這倆夠了；然而我們在圖形學當中經常會需要求得其極坐標，所以我們擴展了Coordinate，增加了一個屬性theta表示角度（反正切的值域為-π/2 ~ π/2，所以這個式子不適用于二三象限，不過這不是重點了），增加了一個R方法來獲得點的半徑，于是我們在main方法中就可以這么用：

fun main(args: Array) {
    val coord = Coordinate(3.0,4.0)
    println(coord.theta)
    println(coord.R())
}

那么這個擴展有什么限制呢？

在擴展成員當中，只能訪問被擴展類在當前作用域內可見的成員，本例中的x和y都是public的（Kotlin默認public，這個我們后面會提到），所以可以在擴展方法和屬性中直接訪問。

擴展成員與被擴展類的內部成員名稱相同時，擴展成員將無法被訪問到

好的，基本知識就是這些了，下面我們再給出一個實際的例子。

通常我們在Java中會自定義一些LogUtils類來打日志，或者直接用android.util.log來輸出日志，不知道大家是什么感受，我反正每次因為要輸入Log.d還要輸入個tag簡直煩的要死，而且有時候恰好這個類還沒有tag這個成員，實踐中我們通常會把當前類名作為TAG，但每個類都要做這么個工作，是在是沒有什么趣味可言（之前我是用LiveTemplates幫我的，即便如此也沒有那種流暢的感覺）。

有了Kotlin的這個擴展功能，日子就會好過得多了，下面我創建的一個打日志的方法：

package com.benny.utils

import android.util.Log

inline fun  T.debug(log: Any){
    Log.d(T::class.simpleName, log.toString())
}

有了這個方法，你可以在任何類的方法體中直接寫：

debug(whatever)

然后就會輸出以這個類名為TAG的日志。

嗯，這里需要簡單介紹Kotlin在泛型中的一個比較重要的增強，這個在Java中無論如何也是做不到的：inline、reified。我們再來回頭看一下debug這個方法，我們發現它可以通過泛型參數T來獲取到T的具體類型，并且拿到它的類名——當然，如果你愿意，你甚至可以調用它的構造方法來構造一個對象出來——為什么Kotlin可以做到呢？因為這段代碼是inline的，最終編譯時是要編譯到調用它的代碼塊中，這時候T的類型實際上是確定的，因而Kotlin通過reified這個關鍵字告訴編譯器，T這個參數可不只是個擺設，我要把它當實際類型來用呢。

為了讓大家印象深刻，我下面給出類似功能的Java的代碼實現：

    public static void debug(Class clazz, Object log){
        Log.d(clazz.getSimpleName(), log.toString());
    }

而你如果說希望在Java中也希望像下面這樣拿到這個泛型參數的類型，是不可以的：

public static  void debug(Object log){
    Log.d(T.getSimpleName(), log.toString());//錯誤，T是泛型參數，無法直接使用
}

就算我們在調用處會寫道 debug < Date >("blabla")，但這個Date在編譯之后還是會被擦除。

Java 8已經開始可以支持Lambda表達式了，這種東西對于Java這樣一個『根紅苗正』的面向對象編程語言來說還真是顯得不自然，不過對于Kotlin來說，就沒那么多顧忌了。

通常我們需要執行一段異步的代碼，我們會構造一個Runnable對象，然后交給executor，比如這段java代碼：

executor.submit(new Runnable(){
    @Override
    public void run(){
        //todo
    }
});

用Kotlin怎么寫呢？

executor.submit({
    //todo
})

一下子省了很多代碼。

那么實際當中我們可能更常見到下面的例子，這是一段很常見的Java代碼，在Android的UI初始化會見到：

textView.setOnClickListener(new OnClickListener(){
    @Override
    public void onClick(View view){
        //todo
    }
});

handle.post(new Runnable(){
    @Override
    public void run(){
        //todo
    }
});

那么我們用Kotlin怎么寫呢？

textView.setOnClickListener{ /*todo*/ }
handler.post{ /*todo*/ }

在Anko這個Android庫的幫助下，我們甚至可以繼續簡化OnClickListener的設置方式：

textView.onClick{ /*todo*/ }

當然，好玩的不止這些，如果結合上一節我們提到的擴展方法，我們就很容易看到Kotlin的標準庫提供的類似with和apply這樣的方法是怎么工作的了：

public inline fun  with(receiver: T, block: T.() -> R): R = receiver.block()

public inline fun  T.apply(block: T.() -> Unit): T { block(); return this }

我們通常會在某個方法體內創建一個對象并返回它，可我們除了調用它的構造方法之外還需要做一些其他的操作，于是就要創建一個局部變量。。。有了apply這個擴展方法，我們就可以這么寫：

fun getStringBuilder: StringBuilder{
    return StringBuilder().apply{
        append("whatever")
    }
}

這樣返回的StringBuilder對象實際上是包含"whatever"這個字符串的。

至于說Kotlin對于RxJava的友好性，使得我突然有點兒相信緣分這種東西了：

       Observable.create> {
            it.onStart()
            try {
                it.onNext(dummyObjs)
            } catch(e: Exception) {
                it.onError(e)
            } finally {
                it.onCompleted()
            }
        }.subscribe(object : Subscriber>() {
            override fun onCompleted() {

            }

            override fun onNext(t: ArrayList?) {

            }

            override fun onError(e: Throwable?) {

            }

        })

記得之前在瀏覽Scala的特性時，看到：

object HelloScala{
  // do something
}

覺得很新鮮，這時候有個朋友不屑的說了句，Scala的模式匹配才真正犀利——Kotlin當中也有這樣的特性，我們下面就來看個例子：

val x = 7
when (x) {
  in 1..10 -> print("x is in the range")
  in validNumbers -> print("x is valid")
  !in 10..20 -> print("x is outside the range")
  else -> print("none of the above")
}

咋一看感覺when表達式就是一個增強版的switch——Java 7以前的switch實際上支持的類型非常有限，Java 7當中增加的對String的支持也是基于int類型的——我們可以看到when不再像switch那樣只匹配一個數值，它的子式可以是各種返回Boolean的表達式。

when表達式還有一種寫法更革命：

when {
  x.isOdd() -> print("x is odd")
  x.isEven() -> print("x is even")
  else -> print("x is funny")
}

只要是返回Boolean的表達式就可以作為when的子式，這樣when表達式的靈活性可見一斑。當然，與Scala相比，Kotlin還是要保守一些的，下面給出一個Scala類似的例子，大家感受一下，這實際上也可以體現出Kotlin在增加Java的同時也盡量保持簡單的設計哲學（大家都知道，畢竟Scala需要智商o(╯□╰)o）。

object Hello {
  def main(args: Array[String]) {
    easyMatch((1, 3))
    easyMatch(Array(1,3,4))
    easyMatch(Bean(3.0, 4.0))
  }

  def easyMatch(value : Any) = value match {
      case int :Int => {
        println("This is an Int.")
      }
      case (a, b) =>{
        println(s"a tuple with : $a , $b")
      }
      case Bean(x, y)  => {
        println(s"$x, $y")
    }
      case whatever => println(whatever)
    }
}

case class Bean(val x: Double, val y: Double)

運行結果如下：

a tuple with : 1 , 3
[I@2d554825
3.0, 4.0

我曾經做過一段時間的SDK開發，SDK的內部有很多類其實是需要互相有訪問權限的，但一旦類及其成員是public的，那么調用方也就可以看到它們了；而protected或者default這樣的可見性對于子包卻是不可見的。

用了這么久Java，這簡直是我唯一強烈感到不滿的地方了，甚至于我突然明白了C++的friend是多么的有用。

Kotlin雖然沒有提供對于子包可見的修飾符，不過它提供了internal：即模塊內可見。換句話說，internal在模塊內相當于public，而對于模塊外就是private了——于是乎我們如果開發SDK，那么可以減少api層的編寫，那些用戶不可見的部分直接用internal豈不更好。當然有人會說我們應當有proguard做混淆，我想說的是，proguard自然是要用到的，不過那是SDK這個產品加工的下一個環節了，我們為什么不能在代碼級別把這個事情做好呢？

關于Kotlin的默認可見性究竟是哪個還有人做出過討論，有興趣的可以參考這里：Kotlin’s default visibility should be internal。

其實我們對DSL肯定不會陌生，gradle的腳本就是基于groovy的DSL，而Kotlin的函數特性顯然也是可以支持DSL的。比如，我們最終要生成下面的xml數據：

我們可以構建下面的類：

class Project {
    var version: String? = null
        get() =
        if (field == null) ""
        else {
            " version="${field}""
        }

    lateinit private var component: Component

    fun component(op: Component.() -> Unit) {
        component = Component().apply {
            op()
        }
    }

    override fun toString(): String {
        return "${component}"
    }


}

fun project(op: Project.() -> Unit): Project {
    return Project().apply {
        op()
    }
}

class Component {
    var name: String? = null
        get() =
        if (field == null) ""
        else {
            " name="${field}""
        }


    lateinit private var file: File

    fun file(op: File.() -> Unit) {
        file = File().apply {
            op()
        }
    }

    override fun toString(): String {
        return "${file}"
    }
}

class File {
    var url: String? = null
        get() =
        if (field == null) ""
        else {
            " url="${field}""
        }

    var charset: String? = null
        get() =
        if (field == null) ""
        else {
            " charset="${field}""
        }

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

fun main(args: Array) {
    val xml = project {
        version = "4"
        component {
            name = "Encoding"
            file {
                url = "PROJECT"
                charset = "UTF-8"
            }
        }
    }

    println(xml)
}

我們看到在main方法當中，我們用kotlin定義的dsl寫出了一個Project對象，它有這與xml描述的一致的結構和含義，如果你愿意，可以構造相應的方法來輸出這樣的xml，運行之后的結果：

當然，這個例子做的足夠的簡陋，如果你有興趣也可以抽象出"Element"，并為之添加"Attributes"，實際上這也不是很難。

寫了很多代碼，卻發現它們干不了多少事情，終究還是會苦惱的。比如我一直比較痛苦的一件事兒就是：

Button button = (Button) findViewById(R.id.btn);

如果我需要很多個按鈕和圖片，那么我們要寫一大片這樣的findViewById。。媽呀。。。這活我干不了啦。。

不過用Kotlin的Android擴展插件，我們就可以這樣：

先上布局文件：

main.xml

在Activity中：

package com.benny

……
import kotlinx.android.synthetic.main.load_activity.*
import org.jetbrains.anko.onClick
import org.jetbrains.anko.startActivity
import org.jetbrains.anko.toast
……

class LoadActivity : Activity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)

        start.onClick {
            toast("開始")
            startActivity()
        }
        textView.text = "你好"
              
    }
}

注意到：

import kotlinx.android.synthetic.main.load_activity.*

導入這一句之后，我們就可以直接在代碼中使用start、textView，他們分別對應于main.xml中的id為start的按鈕和id為textView的TextView。

于是你就發現你再也不用findViewById了，多么愉快的一件事！！！當然，你還會發現Toast的調用也變得簡單了，那其實就是一個擴展方法toast()；而startActivity呢，其實就是一個inline加reified的應用——這我們前面都提到過了。

還有一個惡心的東西就是UI線程和非UI線程的切換問題。也許你會用handler不斷的post，不過說真的，用Handler的時候難道你不顫抖么，那可是一個很容易內存泄露的魔鬼呀~哈哈，好吧其實我不是說這個，主要是用handler寫出來的代碼 實在 太 丑 了 ！！

原來在java當中，我們這么寫：

handler.post(new Runnable(){
    @Override
    public void run(){
        //todo    
    }
});

MainActivity.this.runOnUiThread(
    public void run(){
        //todo
    }
});

而在Kotlin當中呢，我們只需要這么寫：

async() {
    //do something asynchronously
    uiThread {
        //do something on UI thread
    }
}

自己感受一下吧。

下面我們再來提一個有意思的東西，我們從做Android開發一開始就要編寫xml，印象中這個對于我來說真的是一件痛苦的事情，因為它的工作機制并不如代碼那樣直接（以至于我現在很多時候居然喜歡用Java代碼直接寫布局）——當然，最主要的問題并不是這個，而是解析xml需要耗費CPU。Kotlin有辦法可以解決這個問題，那就是DSL了。下面給出一個例子：

linearLayout {
    button("Login") {
        textSize = 26f
    }.lparams(width = wrapContent) {
        horizontalMargin = dip(5)
        topMargin = dip(10)
    }
}

一個LinearLayout包含了一個Button，這段代碼你可以直接寫到你的代碼中靈活復用，就像這樣：

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContentView(linearLayout {
            button("This is a button") {
                onClick {
                    toast("clicked!")
                }
            }.lparams {
                width = matchParent
                verticalMargin = dip(5)
            }
        })
    }

這樣做的好處真是不少：

比起xml的繁瑣來，這真是要清爽很多

布局本身也是代碼，可以靈活復用

再也不用findViewById了，難道你不覺得在這個上面浪費的生命已經足夠多嗎

事件監聽很方便的嵌到布局當中

DSL方式的布局沒有運行時的解析的負擔，你的邏輯代碼怎么運行它就怎么運行

Anko還增加了更多好玩的特性，有興趣的可以參考：Anko@Github

我曾經嘗試用Scala寫了個Android的HelloWorld，一切都配置好以后，僅僅引入了Scala常見的幾個庫，加上support-v4以及appcompat這樣常見的庫，結果還是報錯了。是的，65K。。。而且用Scala開發Android的話，基于gradle的構建會讓整個app的build過程異常漫長，有時候你會覺得自己悟出了廣義相對論的奧義，哦不，你一定是暈了，時間并沒有變慢。

相比之下，Kotlin的標準庫只有7000個方法，比support-v4還要小，這正反映了Kotlin的設計理念：100% interoperable with Java。其實我們之前就提到，Java有的Kotlin就直接拿來用，而Scala的標準庫要有5W多個方法，想想就還是想想算了。

目前Kotlin 1.0已經release，盡管像0xffffffff識別成Long類型這樣的bug仍然沒有解詳情：

val int: Int = 0xffffffff // error
val anotherInt: Int = 0xffffffff.toInt() // correct

不過，Kotlin的教學資源和社區建設也已經相對成熟，按照官方的說法，Kotlin可以作為生產工具投入開發，詳情可以參考：Kotlin 1.0 Released: Pragmatic Language for JVM and Android。

敢于吃螃蟹，多少有些浪漫主義色彩，我們這些程序員多少可以有些浪漫主義特質，不過在生成環境中，穩定高于一切仍然是不二法則。追求新技術，一方面會給團隊帶來開發和維護上的學習成本，另一方面也要承擔未來某些情況下因為對新技術不熟悉而產生未知問題的風險——老板們最怕風險了~~

基于這一點，毫無疑問，Kotlin可以作為小工具、測試用例等的開發工具，這是考慮到這些代碼通常體量較小，維護人數較少較集中，對項目整體的影響也較小；而對于核心代碼，則視情況而定吧。

就我個人而言，長期下去，Kotlin很大可能會成為我的主要語言，短期內則仍然采用溫和的改革方式慢慢將Kotlin滲透進來。

一句話，Kotlin是用來提升效率的，如果在你的場景中它做不到，甚至成了拖累，請放開它。

如果你覺得內容意猶未盡，如果你想了解更多相關信息，請掃描以下二維碼，關注我們的公眾賬號，可以獲取更多技術類干貨，還有精彩活動與你分享~

騰訊Bugly，專業的App Crash監測平臺。監測信息實時上報，讓開發同學可以第一時間了解到App的質量情況，為移動開發節省大量人力與精力，提升移動產品質量。目前騰訊內部所有的移動端產品均在使用，現已免費對外開放。