`Kotlin`团队为`Android`开发提供了一套超越标准语言功能的工具:

- `Kotlin Android Extensions`是一个编译器扩展，可以让您摆脱代码中的`findViewById()`调用，并将其替换为合成编译器生成的属性。

- `Anko`是一个提供围绕`Android API`和`DSL`的一组`Kotlin`友好的包装器，可以用`Kotlin`代码替换`layout .xml`文件。

[Anko](https://github.com/Kotlin/anko)是`Kotlin`官方出品用于`Android`开发的库。

一个Anko扩展函数可以被用来简化获取一个RecyclerView：

val forecastList: RecyclerView = find(R.id.forecast_list)

相信每一位安卓开发人员对`findViewById()`这个方法再熟悉不过了，毫无疑问，潜在的`bug`和脏乱的代码令后续开发无从下手的。 尽管存在一系列的开源库能够为这个问题带来解决方案，然而对于运行时依赖的库，需要为每一个`View`注解变量字段。

现在`Kotlin`安卓扩展插件能够提供与这些开源库功能相同的体验，不需要添加任何额外代码，也不影响任何运行时体验。

另一个`Kotlin`团队研发的可以让开发更简单的插件是`Kotlin Android Extensions`。当前仅仅包括了`view`的绑定。这个插件自动创建了很多的属性来让我们直接访问`XML`中的`view`。这种方式不需要你在开始使用之前明确地从布局中去找到这些`views`。

这些属性的名字就是来自对应`view`的`id`，所以我们取`id`的时候要十分小心，因为它们将会是我们类中非常重要的一部分。这些属性的类型也是来自`XML`中的，所以我们不需要去进行额外的类型转换。

`Kotlin Android Extensions`的一个优点是它不需要在我们的代码中依赖其它额外的库。它仅仅由插件组层，需要时用于生成工作所需的代码，只需要依赖于`Kotlin`的标准库。

开发者仅需要在模块的`build.gradle`文件中启用`Gradle`安卓扩展插件即可:

我们在使用`Android Sutdio 3.0`创建`Kotlin`项目时默认已经添加了该依赖。

import kotlinx.android.synthetic.main.activity_main.*

class MyActivity : Activity() {

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)

setContentView(R.layout.activity_main)

textView.setText("Hello, world!")

// 而不是 findViewById(R.id.textView) as TextView

}

}

`textView`是对`Activity`的一项扩展属性，与在`activity_main.xml`中的声明具有同样类型。

`Kotlin`提供了一些扩展函数来执行网络请求，同时也可以使用第三方库来执行.

public class Request(val url: String) {

public fun run() {

val forecastJsonStr = URL(url).readText()

Log.d(javaClass.simpleName, forecastJsonStr)

}

}

如你所知，HTTP请求不被允许在主线程中执行，否则它会抛出异常。这是因为阻塞住UI线程是一个非常差的体验。Android中通用的做法是使用AsyncTask，但是这些类是非常丑陋的，并且使用它们无任何副作用地实现功能也是非常困难的。Anko提供了非常简单的DSL来处理异步任务，它满足大部分的需求。它提供了一个基本的async函数用于在其它线程执行代码，也可以选择通过调用uiThread的方式回到主线程。在子线程中执行请求如下这么简单：

async() {

Request(url).run()

uiThread { longToast("Request performed") }

}

UIThread有一个很不错的一点就是可以依赖于调用者。如果它是被一个Activity调用的，那么如果activity.isFinishing()返回true，则uiThread不会执行，这样就不会在Activity销毁的时候遇到崩溃的情况了。

`Kotlin`允许我们去定义一些行为与静态对象一样的对象。尽管这些对象可以用众所周知的模式来实现，比如容易实现的单例模式。

我们需要一个类里面有一些静态的属性、常量或者函数，我们可以使用`companion objecvt`。这个对象被这个类的所有对象所共享，就像`Java`中的静态属性或者方法。

public class ForecastRequest(val zipCode: String) {

companion object {

private val APP_ID = "15646a06818f61f7b8d7823ca833e1ce"

private val URL = "http://api.openweathermap.org/data/2.5/" +

"forecast/daily?mode=json&units=metric&cnt=7"

private val COMPLETE_URL = "$URL&APPID=$APP_ID&q="

}

fun execute(): ForecastResult {

val forecastJsonStr = URL(COMPLETE_URL + zipCode).readText()

return Gson().fromJson(forecastJsonStr, ForecastResult::class.java)

}

}

class App : Application() {

companion object {

private var instance: Application? = null

fun instance() = instance!!

}

override fun onCreate() {

super.onCreate()

instance = this

}

}

- with()

inline fun <T> with(t: T, body: T.() -> Unit) { t.body() }

参考

- [Kotlin for Android Developers](https://leanpub.com/kotlin-for-android-developers)

- [Resources to Learn Kotlin](https://developer.android.com/kotlin/resources.html)

- [Kotlin语言中文站](https://www.kotlincn.net/docs/reference/coding-conventions.html)

密封类用来表示受限的类继承结构:当一个值为有限集中的

类型、而不能有任何其他类型时。在某种意义上，他们是枚举类的扩展:枚举类型的值集合

也是受限的，但每个枚举常量只存在一个实例，而密封类

的一个子类可以有可包含状态的多个实例。

要声明一个密封类，需要在类名前面添加`sealed`修饰符。虽然密封类也可以

有子类，但是所有子类都必须在与密封类自身相同的文件中声明。(在`Kotlin 1.1`之前，

该规则更加严格:子类必须嵌套在密封类声明的内部)。

sealed class Expr

data class Const(val number: Double) : Expr()

data class Sum(val e1: Expr, val e2: Expr) : Expr()

object NotANumber : Expr()

fun eval(expr: Expr): Double = when (expr) {

is Const -> expr.number

is Sum -> eval(expr.e1) + eval(expr.e2)

NotANumber -> Double.NaN

}

使用密封类的关键好处在于使用`when`表达式 的时候，如果能够

验证语句覆盖了所有情况，就不需要为该语句再添加一个`else`子句了。

fun eval(expr: Expr): Double = when(expr) {

is Expr.Const -> expr.number

is Expr.Sum -> eval(expr.e1) + eval(expr.e2)

Expr.NotANumber -> Double.NaN

// 不再需要 `else` 子句，因为我们已经覆盖了所有的情况

}

委托模式是最常用的设计模式的一种，在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。`kotlin`中的委托可以算是对委托模式的官方支持。