android kotlin 毫秒时间转时分秒 kotlin monad

Lambdas

Lambda表达式是一种很简单的方法，去定义一个匿名函数。Lambda是非常有用的，因为它们避免我们去写一些包含了某些函数的抽象类或者接口，然后在类中去实现它们。在Kotlin，我们把一个函数作为另一个函数的参数。

简化setOnClickListener()

我们用Android中非常典型的例子去解释它是怎么工作的：View.setOnClickListener()方法。如果我们想用Java的方式去增加点击事件的回调，我首先要编写一个OnClickListener接口：

public interface OnClickListener {
    void onClick(View v);
}

然后我们要编写一个匿名内部类去实现这个接口：

view.setOnClickListener(new OnClickListener(){
    @Override
    public void onClick(View v) {
        Toast.makeText(v.getContext(), "Click", Toast.LENGTH_SHORT).show();
    }
})

我们将把上面的代码转换成Kotlin（使用了Anko的toast函数）：

view.setOnClickListener(object : OnClickListener {
    override fun onClick(v: View) {
        toast("Click")
    }
}

很幸运的是，Kotlin允许Java库的一些优化，Interface中包含单个函数可以被替代为一个函数。如果我们这么去定义了，它会正常执行：

fun setOnClickListener(listener: (View) -> Unit)

一个lambda表达式通过参数的形式被定义在箭头的左边（被圆括号包围），然后在箭头的右边返回结果值。在这个例子中，我们接收一个View，然后返回一个Unit（没有东西）。所以根据这种思想，我们可以把前面的代码简化成这样：

view.setOnClickListener({ view -> toast("Click")})

这是非常棒的简化！当我们定义了一个方法，我们必须使用大括号包围，然后在箭头的左边指定参数，在箭头的右边返回函数执行的结果。如果左边的参数没有使用到，我们甚至可以省略左边的参数：

view.setOnClickListener({ toast("Click") })

如果这个函数的最后一个参数是一个函数，我们可以把这个函数移动到圆括号外面：

view.setOnClickListener() { toast("Click") }

并且，最后，如果这个函数只有一个参数，我们可以省略这个圆括号：

view.setOnClickListener { toast("Click") }

比原始的Java代码简短了5倍多，并且更加容易理解它所做的事情。非常让人影响深刻。

ForecastListAdapter的click listener

在前面一章，我这么艰苦地写了click listener的目的就是更好的在这一章中进行开发。然而现在是时候把你学到的东西用到实践中去了。我们从ForecastListAdapter中删除了listener接口，然后使用lambda代替：

public class ForecastListAdapter(val weekForecast: ForecastList,
                                 val itemClick: (Forecast) -> Unit)

这个itemClick函数接收一个forecast参数然后不返回任何东西。ViewHolder中也可以这么修改：

class ViewHolder(view: View, val itemClick: (Forecast) -> Unit)

其它的代码保持不变。仅仅改变MainActivity：

val adapter = ForecastListAdapter(result) { forecast -> toast(forecast.date) }

我们可以简化最后一句。如果这个函数只接收一个参数，那我们可以使用it引用，而不用去指定左边的参数。所以我们可以这么做：

val adapter = ForecastListAdapter(result) { toast(it.date) }

扩展语言

多亏这些改变，我们可以去创建自己的builder和代码块。我们已经在使用一些有趣的函数，比如with。如下简单的实现：

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

这个函数接收一个T类型的对象和一个被作为扩展函数的函数。它的实现仅仅是让这个对象去执行这个函数。因为第二个参数是一个函数，所以我们可以把它放在圆括号外面，所以我们可以创建一个代码块，在这这个代码块中我们可以使用this和直接访问所有的public的方法和属性：

with(forecast) {
    Picasso.with(itemView.ctx).load(iconUrl).into(iconView)
    dateView.text = date
    descriptionView.text = description
    maxTemperatureView.text = "$high"
    minTemperatureView.text = "$low"
    itemView.setOnClickListener { itemClick(this) }
}

内联函数

内联函数与普通的函数有点不同。一个内联函数会在编译的时候被替换掉，而不是真正的方法调用。这在一些情况下可以减少内存分配和运行时开销。举个例子，如果我们有一个函数，只接收一个函数作为它的参数。如果是一个普通的函数，内部会创建一个含有那个函数的对象。另一方面，内联函数会把我们调用这个函数的地方替换掉，所以它不需要为此生成一个内部的对象。

另一个例子：我们可以创建代码块只提供Lollipop或者更高版本来执行：

inline fun supportsLollipop(code: () -> Unit) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        code()
    }
}

它只是检查版本，然后如果满足条件则去执行。现在我们可以这么做：

supportsLollipop {
    window.setStatusBarColor(Color.BLACK)
}

举个例子，Anko也是基于这个思想来实现Android Layout的DSL化。你也可以查看Kotlin reference中使用DSL来编写HTML的一个例子。

可见性修饰符

Kotlin中这些修饰符是与我们Java中的使用是有些不同的。在这个语言中默认的修饰符是public，这节约了很多的时间和字符。但是这里有一个详细的解释关于在Kotlin中不同的可见性修饰符是怎么工作的。

修饰符

private

private修饰符是我们使用的最限制的修饰符。它表示它只能被自己所在的文件可见。所以如果我们给一个类声明为private，我们就不能在定义这个类之外的文件中使用它。另一方面，如果我们在一个类里面使用了private修饰符，那访问权限就被限制在这个类里面了。甚至是继承这个类的子类也不能使用它。所以一等公民，类、对象、接口……（也就是包成员）如果被定义为private，那么它们只会对被定义所在的文件可见。如果被定义在了类或者接口中，那它们只对这个类或者接口可见。

protected

这个修饰符只能被用在类或者接口中的成员上。一个包成员不能被定义为protected。定义在一个成员中，就与Java中的方式一样了：它可以被成员自己和继承它的成员可见（比如，类和它的子类）。

internal

如果是一个定义为internal的包成员的话，对所在的整个module可见。如果它是一个其它领域的成员，它就需要依赖那个领域的可见性了。比如，如果我们写了一个private类，那么它的internal修饰的函数的可见性就会限制与它所在的这个类的可见性。我们可以访问同一个module中的internal修饰的类，但是不能访问其它module的。

什么是module根据Jetbrains的定义，一个module应该是一个单独的功能性的单位，它应该是可以被单独编译、运行、测试、debug的。根据我们项目不同的模块，可以在Android Studio中创建不同的module。在Eclipse中，这些module可以认为是在一个workspace中的不同的project。

public

你应该可以才想到，这是最没有限制的修饰符。这是默认的修饰符，成员在任何地方被修饰为public，很明显它只限制于它的领域。一个定义为public的成员被包含在一个private修饰的类中，这个成员在这个类以外也是不可见的。

构造器

所有构造函数默认都是public的，它们类是可见的，可以被其它地方使用。我们也可以使用这个语法来把构造函数修改为private：

class C private constructor(a: Int) { ... }

润色我们的代码

我们已经准备好使用public来进行重构了，但是我们还有很多其它细节需要修改。比如，在RequestForecastCommand中，我们在构造函数中我们创建的属性zipCode可以定义为private：

class RequestForecastCommand(private val zipCode: String)

所作的事情就是我们创建了一个不可修改的属性zipCode，它的值我们只能去得到，不能去修改它。所以这个不大的改动让代码看起来更加清晰。如果我们在编写类的时候，你觉得某些属性因为是什么原因不能对别人可见，那就把它定义为private。

而且，在Kotlin中，我们不需要去指定一个函数的返回值类型，它可以让编译器推断出来。举个省略返回值类型的例子：

data class ForecastList(...) {
    fun get(position: Int) = dailyForecast[position]
    fun size() = dailyForecast.size()
}

我们可以省略返回值类型的典型情景是当我们要给一个函数或者一个属性赋值的时候。而不需要去写代码块去实现。

剩下的修改是相当简单的，你可以在代码库中去同步下来。

Kotlin Android Extensions

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

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

Kotlin Android Extensions的一个优点是它不需要在我们的代码中依赖其它额外的库。它仅仅由插件组层，需要时用于生成工作所需的代码，只需要依赖于Kotlin的标准库。那它背后是怎么工作的？该插件会代替任何属性调用函数，比如获取到view并具有缓存功能，以免每次属性被调用都会去重新获取这个view。需要注意的是这个缓存装置只会在Activity或者Fragment中才有效。如果它是在一个扩展函数中增加的，这个缓存就会被跳过，因为它可以被用在Activity中但是插件不能被修改，所以不需要再去增加一个缓存功能。

怎么去使用Kotlin Android Extensions

如果你还记得，现在项目已经准备好去使用Kotlin Android Extensions。当我们创建这个项目，我们就已经在build.gradle中增加了这个依赖：

buldscript{
    repositories {
        jcenter()
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-android-extensions:$kotlin_version"
    }
}

唯一一件需要这个插件做的事情是在类中增加一个特定的"手工"import来使用这个功能。我们有两个方法来使用它：

Activities或者Fragments的Android Extensions

这是最典型的使用方式。它们可以作为activity或fragment的属性是可以被访问的。属性的名字就是XML中对应view的id。我们需要使用的import语句以kotlin.android.synthetic开头，然后加上我们要绑定到Activity的布局XML的名字：

import kotlinx.android.synthetic.activity_main.*

此后，我们就可以在setContentView被调用后访问这些view。新的Android Studio版本中可以通过使用include标签在Activity默认布局中增加内嵌的布局。很重要的一点是，针对这些布局，我们也需要增加手工的import：

import kotlinx.android.synthetic.activity_main.*
import kotlinx.android.synthetic.content_main.*

Views的Android Extensions

前面说的使用还是有局限性的，因为可能有很多代码需要访问XML中的view。比如，一个自定义view或者一个adapter。举个例子，绑定一个xml中的view到另一个view。唯一不同的就是需要import：

import kotlinx.android.synthetic.view_item.view.*

如果我们需要一个adapter，比如，我们现在要从inflater的View中访问属性：

view.textView.text = "Hello"

重构我们的代码

现在是时候使用Kotlin Android Extensions来修改我们的代码了。修改相当简单。我们从MainActivity开始。我们当前只是使用了forecastList的RecyclerView。但是我们可以简化一点代码。首先，为activity_mainXML增加手工import：

import kotlinx.android.synthetic.activity_main.*

之前说过，我们使用id来访问views。所以我要修改RecyclerView的id，不使用下划线，让它更加适合Kotlin变量的名字。XML最后如下：

<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <android.support.v7.widget.RecyclerView
        android:id="@+id/forecastList"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>
</FrameLayout>

然后现在，我们可以不需要find这一行了：

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    forecastList.layoutManager = LinearLayoutManager(this)
    ...
}

这已经是最小的简化了，因为这个布局非常简单。但是ForecastListAdapter也可以从这个插件中受益。这里你可以使用一个装置来绑定这些属性到view中，它可以帮助我们移除所有ViewHolder的find代码。首先，为item_forecast增加手工导入：

import kotlinx.android.synthetic.item_forecast.view.*

然后现在我们可以在ViewHolder中使用包含在itemView中的属性。实际上你可以在任何view中使用这些属性，但是很显然如果view不包含要获取的子view就会奔溃。

现在我们可以直接访问view的属性了：

class ViewHolder(view: View, val itemClick: (Forecast) -> Unit) :
        RecyclerView.ViewHolder(view) {
    fun bindForecast(forecast: Forecast) {
        with(forecast){
            Picasso.with(itemView.ctx).load(iconUrl).into(itemView.icon)
            itemView.date.text = date
            itemView.description.text = description
            itemView.maxTemperature.text = "${high.toString()}"
            itemView.minTemperature.text = "${low.toString()}"
            itemView.onClick { itemClick(forecast) }
        } 
    }
}

Kotlin Android Extensions插件帮助我们减少了很多模版代码，并且简化了我们访问view的方式。从库中检出最新的代码吧。