快速切换至Kotlin for Android模式

前言

几个特性，快速上手Kotlin

充分理解Kotlin，快速上手写业务

快速切换至Kotlin for Android模式

聊一聊Kotlin中的协程，真香

关于Kotlin的文章，已经构思了好久。一直不知道该怎么写。文档式文章？那不如直接看文档，何须须要我再多“哔哔”呢。思来想后，决定写一篇快速在Android开发中感觉Kotlin的其妙的文章。

说实话，最开始搞Kotlin我是拒绝的。为啥？由于彻底没有感受到用它替换Java开发有什么实质性的改变；并且感受语法很“别扭”！（其实说白了，就是不想学，给本身找借口。哈哈）

可是，后来机缘巧合却感觉到了Kotlin的有趣之处。固然这一切的开始，要克服写久了Java的那一种“别扭”（由其是在Lambda写的也很少的状况下）。OK，不扯了。文章将从我接触Kotlin时，遇到“别扭”的地方开始展开。

正文

静态方法

第一个让我懵逼的是静态方法。在Kotlin里边被叫作了：伴生对象。这里不扯“花里胡哨”的介绍。直接上代码：

public class StringUtils{
	public static void myFun(){
		Log.d("StringUtils","Haha");
	}
}
复制代码

在Java中这么一个简单工具类中的静态方法，Kotlin要怎么写？

class StringUtils{
    companion object {
        fun myFun(){
            Log.d("StringUtils","Haha")
        }
    }
}
复制代码

匿名内部类

setOnClickListener是咱们比较经常使用的匿名内部类的使用场景：

btn.setOnClickListener(new View.OnClickListener() {
	@Override
	public void onClick(View v) {
		Log.d("Listener","Haha")
	}
}
复制代码

那么到了Kotlin中又是什么样子了呢？

btn.setOnClickListener {
	Log.d("Listener","Haha")
}
复制代码

直接帮咱们Lambda化了。若是咱们不想Lambda化那应该是什么样子？

btn.setOnClickListener(object : View.OnClickListener{
	override fun onClick(v: View?) {
		Log.d("Listener","Haha")
	}
})
复制代码

也没什么特别的，其实就是Kotlin的语法。由于Kotlin里边声明的变量要写在前面，其类型用:号隔开，写在后面。也就是如今这个样子。不过须要注意的，这里的object表明匿名对象类型。

这里有一个小细节，不知道大兄弟们有没有注意到。在Java中咱们new匿名内部类的时候：new View.OnClickListener(){}，是有()的。而在Kotlin中则：View.OnClickListener{}没有()。这里也是属于语法细节，加上()表示显示的调用这个类的构造方法。

若是这样的话，那就和new普通的类，没什么区别的（而不是匿名内部类）。借着匿名内部类，咱们直接来看一下Kotlin在RxJava中的实战。

Kotlin in RxJava

先看一个很简单的Java用法：

Observable.just(0)
          .map(new Function<Integer, String>() {
              @Override
              public String apply(Integer integer) throws Exception {
                  return integer.toString();
              }
          })
          .subscribe(new Consumer<String>() {
              @Override
              public void accept(String s) throws Exception {
	              Log.d("RxJava", s);
              }
          }, new Consumer<Throwable>() {
              @Override
              public void accept(Throwable throwable) throws Exception {
	              Log.d("RxJava", throwable.getMessage());
              }
          });
复制代码

对于Kotlin来讲，在Lambda的加持之下，写法变得异常的简洁（固然Java进行Lambda化也很简洁）：

Observable.just(0)
          .map({ it!!.toString() })
          .subscribe({ t: String -> Log.d("RxJava", t)
          }, { t: Throwable -> Log.d("RxJava", t.message) })
复制代码

若是对Lambda不是很熟悉的大兄弟们，确定有点懵。那么我们换成普通的kotlin,，是否是感受很熟悉？object又出现了，没错这里就是普通的匿名内部类而已。

Observable.just(0)
          .map(object : Function<Int, String> {
              override fun apply(t: Int): String {
                  return t.toString()
              }
          })
          .subscribe(object : Consumer<String> {
              override fun accept(t: String) {
                  Log.d("RxJava", t)
              }
          }, object : Consumer<Throwable> {
              override fun accept(t: Throwable) {
                  Log.d("RxJava", t.message)
              }
          })
复制代码

Kotlin in Adapter

上述的几块代码，咱们一块儿感觉了Kotlin在RxJava中的变形。说实话，若是抛出Lambda，真心谈不上什么大的变化。就是语法上的转变。聊过了咱们平常开发比重比较大的RxJava，接下来咱们再来看一看另外一个重头戏Adapter。这里直接上Kotlin代码：

class TestAdapter(var data: List<String>,var context:Context) : RecyclerView.Adapter<TestAdapter.ViewHolder>() {
    override fun onCreateViewHolder(parent: ViewGroup?, viewType: Int): ViewHolder {
        return ViewHolder(TextView(context))
    }

    override fun getItemCount(): Int {
        return data.size
    }

    override fun onBindViewHolder(holder: ViewHolder?, position: Int) {
        holder!!.textView.text = "Haha"
    }

    class ViewHolder(var textView: TextView) : RecyclerView.ViewHolder(textView)
}
复制代码

最开始看这个代码的时候，我是有点懵的，感受不知所措。其实带入Kotlin的语法，很是的好理解。在最开始声明这个class的时候，咱们直接在TestAdapter的主构造方法中声明了两个var的变量。这种写法就相似于Java中的：

class TestAdapter {
    public List<String> data;
    public Context context;

    public TestAdapter(List<String> data, Context context) {
        this.data = data;
        this.context = context;
    }
}
复制代码

这也就是为何咱们能在class里边随意调用data和context的缘由。

注意var，若是咱们在构造方法中声明时不加上var，就能够理解为这个变量是局部变量。只适用于构造方法中。

这中间override的代码应该没什么好说的，咱们来看一下最后声明的class ViewHolder。正常来讲咱们在Java中的ViewHolder都是这个样子：

public class ViewHolder extends RecyclerView.ViewHolder {
    public TextView textView;

    public ViewHolder(TextView textView) {
        super(textView);
        this.textView= textView;
    }
}
复制代码

那为何到了Kotlin之中，就变成了短短的一行class ViewHolder(var textView: TextView) : RecyclerView.ViewHolder(textView)了呢？其实也没有什么神奇的，就是正常语法而已。 这小结开始的时候，咱们提到了主构造方法，以及在匿名内部类这个小结中提到加上()表示显示的调用这个类的构造方法。 所以Kotlin的这段代码很是的好理解：

就是把主构造方法中传递的textView，传给RecyclerView.ViewHolder()构造方法中。也就是和咱们的Java代码一毛同样的，只是写法不一样罢了。

尾声

OK，关于Kotlin在咱们Android开发这些别扭的地方就暂时写到这。其实说白了，这些都是最基本的语法问题。这里挑出来的这几个Android的场景，是我在自觉得学会语法的时候，以为别扭的地方。固然别扭的缘由仍是由于本身对语法并不够理解。因此才有了这篇文章，但愿能够给正准备走上Kotlin这条路上的大兄弟们一些帮助吧~

我是一个应届生，最近和朋友们维护了一个公众号，内容是咱们在从应届生过渡到开发这一路所踩过的坑，以及咱们一步步学习的记录，若是感兴趣的朋友能够关注一下，一同加油~