1、Hello, Kotlin
Bugly 技術乾貨系列內容主要涉及移動開發方向，是由 Bugly 邀請騰訊內部各位技術大咖，通過日常工作經驗的總結以及感悟撰寫而成，內容均屬原創，轉載請標明出處。
1.1 Kotlin的身世
-
寫了許久Java，有沒有發現其實你寫了太多冗餘的程式碼？
-
後來你體驗了一下Python，有沒有覺得不寫分號的感覺真是超級爽？
-
你雖然勤勤懇懇，可到頭來卻被NullPointerException折磨的死去活來，難道就沒有受夠這種日子麼？
-
直到有一天你發現自己已經寫了好幾十萬行程式碼，發現居然全是getter和setter！
哈哈，實際上你完全可以不用這麼痛苦，用Kotlin替代Java開發你的程式，無論是Android還是Server，你都能像之前寫Java一樣思考，同時又能享受到新一代程式語言的特性，說到這裡你是不是開始心動了呢？下面我就通過這篇文章來給大家介紹一下Kotlin究竟是何方神聖。
話說，Kotlin是JetBrain公司搞出來的，執行在JVM上的一門靜態型別語言，它是用波羅的海的一個小島的名字命名的。從外觀上，乍一看還以為是Scala，我曾經琢磨著把Scala作為我的下一門語言，不過想想用Scala來幹嘛呢，我又不做大資料，而它又太複雜了o(╯□╰)o
用Kotlin建立一個資料類
data class Mondai(var index: Int = 0,
var title: String = "",
val ans: ArrayList<String> = ArrayList(),
var correct: Int = 0,
var comment: String = "",
var color: String = "",
private var lives: Int = 50)
最初是在intelliJ的原始碼中看到Kotlin的，那時候Kotlin的版本還不太穩定，所以原始碼總是編譯不過，真是要抓狂啊，還罵『什麼破玩意兒！為什麼又出來新語言了？Groovy還沒怎麼學會，又來個Kotlin！』話說，Kotlin，難道是『靠它靈』的意思？？
其實經過一年多的發展，Kotlin 1.0已經release，feature基本完善，api也趨於穩定，這時候嘗試也不會有那種被坑的感覺了。過年期間也算清閒，於是用Kotlin做了個app，簡單來說，就是幾個感覺：
- 思路與寫Java時一樣，不過更簡潔清爽
- 少了冗餘程式碼的煩惱，更容易專注於功能的開發，整個過程輕鬆愉快
- 擴充套件功能使得程式碼寫起來更有趣
- 空安全和不可變型別使得開發中對變數的定義和初始化傾注了更多關注
- 啊啊，我再也不用寫那個findViewById了，真的爽爆有木有！
1.2 第一個Kotlin程式
Kotlin開發當然使用JetBrain系列的IDE，實際上intelliJ idea 15釋出時就已經內建了Kotlin外掛，更早的版本則需要到外掛倉庫中下載安裝Kotlin外掛——在安裝時你還會看到有個Kotlin Extensions for Android，不要管他，已經過時了。安裝好以後，我們就可以使用Kotlin進行開發了。
接下來我們用Android Studio建立一個Android工程，比如叫做HelloKotlin，在app目錄下面的build.gradle檔案中新增下面的配置：
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
ext.anko_version = '0.8.2'
ext.kotlin_version = '1.0.0'
……
dependencies{
……
compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
compile "org.jetbrains.anko:anko-sdk15:$anko_version"
compile "org.jetbrains.anko:anko-support-v4:$anko_version"
compile "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
……
}
buildscript {
repositories {
jcenter()
}
dependencies {
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}
}
……
這裡新增了kotlin對android的擴充套件，同時也新增了kotlin的gradle外掛。
接下來就可以編寫kotlin程式碼了——等等，Android Studio會幫我們生成一個MainActivity，你可以直接在選單
Code -> Convert Java file to Kotlin file
將這個java程式碼轉換為kotlin程式碼。截止到現在，你什麼都不用做，程式就已經可以跑起來了。
2、完美為Java開發者打造
2.1 通用的集合框架
我們都知道Jvm上面的語言，像什麼Java、Groovy、Jython啥的，都是要編成虛擬機器的位元組碼的，一旦編成位元組碼，在一定程度上大家就都平等了。
英雄不問出身啊
有人做過一個非常形象的比喻：Java虛擬機器語言就是打群架。Kotlin正是充分利用了這一點，它自己的標準庫只是基於Java的語言框架做了許多擴充套件，你在Kotlin當中使用的集合框架仍然跟你在Java當中一樣。
舉個例子，如果你想要在Kotlin中使用ArrayList，很簡單，Java的ArrayList你可以隨意使用，這個感覺跟使用Java沒有任何區別，請看：
//實際上就是建立一個ArrayList
val list = arrayListOf(1,2,3,4)
list.add(5)
list.remove(3)
for(item in list){
println(item)
}
當然，Kotlin標準庫也對這些做了擴充套件，我們在享用Java世界的一切資源的同時，還能比原生Java程式碼更滋潤，真是爽爆有木有：
val list = arrayListOf(1, 2, 3, 4, 5)
//doubleList = [2,4,6,8,10]
val doubleList = list.map {
it * 2
}
//oddList = [1,3,5]
val oddList = list.filter{
it % 2 == 1
}
//將list挨個列印出來
list.forEach {
println(it)
}
2.2 與Java互動
Kotlin的標準庫更多的是對Java庫的擴充套件，基於這個設計思路，你絲毫不需要擔心Kotlin對Java程式碼的引用，你甚至可以在Kotlin當中使用Java反射，反正只要是Java有的，Kotlin都有，於是有人做出這樣的評價：
Kotlin就是Java的一個擴充套件
這樣說Kotlin顯然是不公平的，但就像微信剛面世那會兒要為QQ接收離線訊息一樣，總得抱幾天大腿嘛。
有關從Kotlin中呼叫Java的官方文件在此Calling Java code from Kotlin ，其中最常見的就是Getter/Setter方法對應到Kotlin屬性的呼叫，舉個例子：
準備一個Java類
public class JavaClass {
private int anInt = 0;
public int getAnInt() {
return anInt;
}
public void setAnInt(int anInt) {
this.anInt = anInt;
}
}
下面是Kotlin程式碼
val javaClass = JavaClass()
javaClass.anInt = 5
print(javaClass.anInt)
所以我們在Android開發時，就可以這樣：
view.background = ...
textView.text = ...
反過來在Java中呼叫Kotlin也毫無壓力，官方文件Calling Kotlin from Java對於常見的情況作了比較詳細的闡述，這裡就不再贅述。
3、簡潔，可靠，有趣
3.1 資料類
最初學Java的時候，學到一個概念叫JavaBean，當時就要被這個概念給折磨死了。明明很簡單的一個東西，結果搞得很複雜的樣子，而且由於當時對於這些資料類的設計概念不是很清晰，因而也並不懂得去覆寫諸如equals和hashcode這樣重要的方法，一旦用到HashMap這樣的集合框架，總是出了問題都不知道找誰。
Kotlin提供了一種非常簡單的方式來建立這樣的資料類，例如：
data class Coordinate(val x: Double, val y: Double)
僅僅一行程式碼，Kotlin就會建立出一個完整的資料類，並自動生成相應的equals、hashcode、toString方法。是不是早就受夠了getter和setter？反正我是受夠了。
3.2 空安全與屬性代理
第一次見到空型別安全的設計是在Swift當中，那時候還覺得這個東西有點兒意思哈，一旦要求變數不能為空以後，因它而導致的空指標異常的可能性就直接沒有了。想想每次QA提的bug吧，說少了都得有三分之一是空指標吧。
Kotlin的空安全設計，主要是在型別後面加？表示可空，否則就不能為null。
val anInt: Int = null // 錯誤
val anotherInt: Int? = null // 正確
使用時，則：
val nullable: Int? = 0
val nonNullable: Int = 2
nullable.toFloat() // 編譯錯誤
nullable?.toFloat() // 如果null，什麼都不做，否則呼叫toFloat
nullable!!.toFloat() // 強制轉換為非空物件，並呼叫toFloat；如果nullable為null，拋空指標異常
nonNullable.toFloat() // 正確
而對於Java程式碼，比如我們在覆寫Activity的onCreate方法時，有個引數savedInstanceState：
override fun onCreate(savedInstanceState: Bundle!)
這表示編譯器不再強制savedInstanceState是否可null，開發者在覆寫時可以自己決定是否可null。當然，對於本例，onCreate的引數是可能為null的，因此覆寫以後的方法應為：
override fun onCreate(savedInstanceState: Bundle?)
通常來講，教科書式的講法，到這裡就該結束了。然而直到我真正用Kotlin開始寫程式碼時，發現，有些需求實現起來真的有些奇怪。
還是舉個例子，我需要在Activity當中建立一個View的引用，通常我們在Java程式碼中這麼寫：
public class DemoActivity extends Activity{
private TextView aTextView;
public void onCreate(Bundle savedInstanceState){
super.OnCreate(savedInstanceState);
setContentView(R.layout.main);
aTextView = (TextView) findViewById(R.id.a_textview);
aTextView.setText("Hello");
aTextView.setTextSize(20);
...
}
}
在Kotlin當中呢？
class DemoActivity : Activity(){
private var aTextView: TextView? = null
override fun onCreate(savedInstanceState: Bundle?){
super.onCreate(savedInstanceState)
setContentView(R.layout.main)
//當然有更好用的方式，暫且先這麼寫
aTextView = findViewById(R.id.a_textview) as TextView
aTextView!!.text = "Hello"
aTextView!!.textSize = 20
...
}
}
每次用aTextView都要加倆!，不然編譯器不能確定它究竟是不是null，於是不讓你使用。。這尼瑪。。。到底是為了方便還是為了麻煩？？
所以後來我又決定這麼寫：
class DemoActivity : Activity(){
private var aTextView: TextView // 編譯錯誤，必須初始化！！！
...
}
這可如何是好？？
其實Kotlin肯定是有辦法解決這個問題噠！比如上面的場景，我們這麼寫就可以咯：
class DemoActivity : Activity(){
private val aTextView: TextView by lazy{
findViewById(R.id.a_textview) as TextView
}
override fun onCreate(savedInstanceState: Bundle?){
super.onCreate(savedInstanceState)
setContentView(R.layout.main)
aTextView.text = "Hello"
aTextView.textSize = 20
...
}
}
lazy是Kotlin的屬性代理的一個例項，它提供了延遲載入的機制。換句話說，這裡的lazy提供了初始化aTextView的方法，不過真正初始化這個動作發生的時機卻是在aTextView第一次被使用時了。lazy預設是執行緒安全的，你當然也可以關掉這個配置，只需要加個引數即可：
private val aTextView: TextView by lazy(LazyThreadSafetyMode.NONE){
findViewById(R.id.a_textview) as TextView
}
好，這時候肯定有人要扔西紅柿過來了（再扔點兒雞蛋唄），你這lazy只能初始化val啊，萬一我要定義一個var成語，又需要延遲初始化，關鍵還不為null，怎麼辦？？
class Demo {
lateinit var anJsonObject: JsonObject
fun initDemo(){
anJsonObject = JsonObject("{...}")
}
}
lateinit的使用還是有很多限制的，比如只能在不可null的物件上使用，比須為var，不能為primitives（Int、Float之類）等等，不過這樣逼迫你一定要初始化這個變數的做法，確實能減少我們在開發中的遺漏，從而提高開發效率。
至於lazy技術，實際上是Delegate Properties的一個應用，也就是屬性代理了。在Kotlin當中，宣告成員屬性，除了直接賦值，還可以用Delegate的方式來宣告，這個Delegate需要根據成員的型別（val或者var）來提供相應的getValue和setValue方法，比如一個可讀寫的Delegate，需要提供下面的方法：
public interface ReadWriteProperty<in R, T> {
/**
* Returns the value of the property for the given object.
* @param thisRef the object for which the value is requested.
* @param property the metadata for the property.
* @return the property value.
*/
public operator fun getValue(thisRef: R, property: KProperty<*>): T
/**
* Sets the value of the property for the given object.
* @param thisRef the object for which the value is requested.
* @param property the metadata for the property.
* @param value the value to set.
*/
public operator fun setValue(thisRef: R, property: KProperty<*>, value: T)
}
好嘴皮不如來個栗子，下面我們就看一個自定義Delegate，用來訪問SharedPreference：
class Preference<T>(val context: Context, val name: String, val default: T) : ReadWriteProperty<Any?, T> {
val prefs by lazy { context.getSharedPreferences("default", Context.MODE_PRIVATE) }
override fun getValue(thisRef: Any?, property: KProperty<*>): T {
return findPreference(name, default)
}
override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
putPreference(name, value)
}
private fun <U> findPreference(name: String, default: U): U = with(prefs) {
val res: Any = when (default) {
is Long -> getLong(name, default)
is String -> getString(name, default)
is Int -> getInt(name, default)
is Boolean -> getBoolean(name, default)
is Float -> getFloat(name, default)
else -> throw IllegalArgumentException("This type can be saved into Preferences")
}
res as U
}
private fun <U> putPreference(name: String, value: U) = with(prefs.edit()) {
when (value) {
is Long -> putLong(name, value)
is String -> putString(name, value)
is Int -> putInt(name, value)
is Boolean -> putBoolean(name, value)
is Float -> putFloat(name, value)
else -> throw IllegalArgumentException("This type can be saved into Preferences")
}.apply()
}
}
需要說明的是，這段程式碼是我從《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的日子。有沒有覺得非常贊！
3.3 擴充套件類
擴充套件類，就是在現有類的基礎上，新增一些屬性或者方法，當然擴充套件的這些成員需要匯入當前擴充套件成員所在的包才可以訪問到。下面給出一個例子：
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<String>) {
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 <reified T> 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 <T> void debug(Object log){
Log.d(T.getSimpleName(), log.toString());//錯誤，T是泛型引數，無法直接使用
}
就算我們在呼叫處會寫道 debug < Date >(“blabla”)，但這個Date在編譯之後還是會被擦除。
3.4 函式式支援（Lambdas）
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 <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
public inline fun <T> T.apply(block: T.() -> Unit): T { block(); return this }
我們通常會在某個方法體內建立一個物件並返回它，可我們除了呼叫它的構造方法之外還需要做一些其他的操作，於是就要建立一個區域性變數。。。有了apply這個擴充套件方法，我們就可以這麼寫：
fun getStringBuilder: StringBuilder{
return StringBuilder().apply{
append("whatever")
}
}
這樣返回的StringBuilder物件實際上是包含”whatever”這個字串的。
至於說Kotlin對於RxJava的友好性，使得我突然有點兒相信緣分這種東西了：
Observable.create<ArrayList<Dummy>> {
it.onStart()
try {
it.onNext(dummyObjs)
} catch(e: Exception) {
it.onError(e)
} finally {
it.onCompleted()
}
}.subscribe(object : Subscriber<ArrayList<Dummy>>() {
override fun onCompleted() {
}
override fun onNext(t: ArrayList<Dummy>?) {
}
override fun onError(e: Throwable?) {
}
})
3.5 Pattern Matching
記得之前在瀏覽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
3.6 如果你是一個SDK開發者
我曾經做過一段時間的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。
3.7 DSL
其實我們對DSL肯定不會陌生，gradle的指令碼就是基於groovy的DSL，而Kotlin的函式特性顯然也是可以支援DSL的。比如，我們最終要生成下面的xml資料：
<project version="4">
<component name="Encoding">
<file url="PROJECT" charset="UTF-8" />
</component>
</project>
我們可以構建下面的類：
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 "<project${version}>${component}<project>"
}
}
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 "<component${name}>${file}<component>"
}
}
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 "<file${url}${charset}/>"
}
}
fun main(args: Array<String>) {
val xml = project {
version = "4"
component {
name = "Encoding"
file {
url = "PROJECT"
charset = "UTF-8"
}
}
}
println(xml)
}
我們看到在main方法當中，我們用kotlin定義的dsl寫出了一個Project物件，它有這與xml描述的一致的結構和含義，如果你願意，可以構造相應的方法來輸出這樣的xml，執行之後的結果：
<project version="4"><component name="Encoding"><file url="PROJECT" charset="UTF-8"/><component><project>
當然，這個例子做的足夠的簡陋，如果你有興趣也可以抽象出”Element”，併為之新增”Attributes”，實際上這也不是很難。
3.7 Kotlin與Android的另一些有趣的東西
寫了很多程式碼，卻發現它們幹不了多少事情，終究還是會苦惱的。比如我一直比較痛苦的一件事兒就是：
Button button = (Button) findViewById(R.id.btn);
如果我需要很多個按鈕和圖片，那麼我們要寫一大片這樣的findViewById。。媽呀。。。這活我幹不了啦。。
不過用Kotlin的Android擴充套件外掛，我們就可以這樣：
先上佈局檔案：
main.xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@drawable/open_bj"
android:orientation="vertical">
<TextView
android:id="@+id/textView"
android:text="Hello"
android:textSize="50sp"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
<Button
android:id="@+id/start"
android:clickable="false"
android:layout_gravity="center_horizontal"
android:background="@drawable/start_selector"
android:textSize="50sp"
android:layout_marginTop="20dp"
android:layout_marginBottom="200dp"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
</RelativeLayout>
在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<AnotherActivity>()
}
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
3.8 方法數之痛
我曾經嘗試用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多個方法，想想就還是想想算了。
4、小結
目前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簡介
騰訊Bugly，專業的App Crash監測平臺。監測資訊實時上報，讓開發同學可以第一時間瞭解到App的質量情況，為移動開發節省大量人力與精力，提升移動產品質量。目前騰訊內部所有的移動端產品均在使用，現已免費對外開放。