kotlin学习记录

kotlin

将一个activity的java文件转为kotlin文件

最简单的转化方式

android stutdio支持一键转化的方式，通过快捷键ctrl +alt + shift + k将整个java文件转化为kt文件，不过可能需要自己解决一些代码不一致的冲突，而且有些时候转化后的代码和我们直接写的代码还是有差别的。

环境配置

kotlin库引入

android studio3.0默认支持kotlin，虽然是默认支持kotlin，但也是需要增加一些配置，不过这个as已经给我们做好了智能提示和自动添加的功能。在我们第一次创建出kt文件的时候，将会有一个kotlin的配置提示，我们只需要点击configure，然后选择全局配置，那么as将会在gradle中添加上kotlin的依赖
[图片上传失败…(image-4852fe-1542511738777)]
gradle文件如下所示:
[图片上传失败…(image-17de9f-1542511738777)]
这样我们就使用kotlin的代码库了。

kotlin extension库引入

之前项目中用的是view的绑定库是ButterKnife，就个人而言，还是觉得挺好用的，毕竟绑定View的代码都能自动生成，不过如果在kt文件中，不能直接引入这个库，需要重新引入kotlin中的ButterKnife库https://github.com/JakeWharton/kotterknife，不过我们可以不用这个库了，因为kotlin给我们提供了一套更为简便的库，我们只需要在gradle中引入kotlin-extension，并且在kt文件中import相对应的xml，就能直接通过id的方式引用view。

//在kt文件中
import kotlinx.android.synthetic.main.activity_member_center.*

//在gradle文件中
apply plugin: 'kotlin-android-extensions'

比如说我们在xml中有这样一个View：

 <android.support.v7.widget.RecyclerView
        android:id="@+id/memberRv"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_below="@+id/member_center_tool_bar"
        android:layout_centerHorizontal="true" />

这样我们在kt文件中，可以像下面的方式这样调用：

private fun initRv() {
        adapter = MemberInfoAdapter(this, null)
        memberRv.layoutManager = LinearLayoutManager(this)
        memberRv.itemAnimator?.changeDuration = 0
        memberRv.adapter = adapter
    }

这个memberRv就是RecyclerView在xml中指定的id。

一些常用用法

参数定义

修饰符

在kotlin中，声明所有变量都需要3个关键字修饰，var、val和const。在kotlin中是没有final修饰符的，final修饰符在kotlin中其实就相当于val

• var:主要是用来修饰可变变量的。
• val：主要是用来修饰不可变变量的，其实也不能说是不可变，更好的称呼是叫做只读变量，val在修饰变量的时候可以不初始化，但是它不能被赋值，在java中，用final修饰的变量必须要初始化，否则编译不能通过。举个val修饰不初始化的例子：

      class a {
      var c = 1;
      val b: String
      fun getB(): String {
          return c > 3 ? "haha" : "xixi"
      }
      
      fun add() {
          c++
      }
      
      }
  

• const:其实const就和java中的static final一致了，不能放在局部方法中，在编译期间必须确定变量值。

静态变量及静态方法

在java中，静态属性和静态方法只需要一个static属性就能搞定了，但是在kotlin，它有一个单独的块来标识静态块的初始化，companion object:

companion object {
        val intentFrom: String = "intent_extra"
        fun startMemberCenterActivity(context: Context,                 launchMemberCenter: LaunchMemberCenter) {
            var intent = Intent(context, TestAc::class.java)
            intent.putExtra(intentFrom, launchMemberCenter)
            if (context is Activity) {
                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
            }
            context.startActivity(intent)
        }
    }

这个代码块有几个需要注意的点，

• 在kt定义Intent中，class的指定需要已类名::class.java的方式指定，否则在log中会提示找不到activity
• 在这个静态块中，定义的变量和方法都是静态的
• 在外部如果需要访问这个块的方法，如果是kotlin文件访问，可以直接通过类名.的方式调用，如果是java文件访问，需要通过类名.companion.的方式调用:

//在java文件中调用
public void start() {
       TestAc.Companion.startMemberCenterActivity(context, this);
   }
//在kt文件中调用
public void start() {
       TestAc.startMemberCenterActivity(context, this);
   }

kotlin的空指针安全

在变量定义时，我们可以通过kotlin特有的方式来标识变量是否可空：

private var adapter: MemberInfoAdapter? = null

只需要的变量类型后面添加?，就表示这个变量是可以为null的，如果不添加，默认这个变量不能为null。一旦我们添加了?，在后续的代码中，如果有引用到这个变量的地方，如果没有做判空处理将会编译不过，这个判空处理还是挺方便的，

 override fun refreshDiscoveryList(mixFindInfoList: MutableList<MixFindInfo>?) {
        adapter?.notifyMixFindInfoChange(mixFindInfoList)
    }

Equality check should be used instead of elvis for nullable boolean check
在调用时，如果adaper为空了，将不会执行后续的操作。
今天遇到了一个符号:

var xie = a ?: ""

这个?:是kotlin的elvis用法，属于两目运算符，就是简单的if、else缩写，
当a不为null，取a的值，当a为null，取""

接口使用

kotlin接口和java接口的使用区别

class TestAc : BaseMvpActivity<MemberCenterPresent>(), MemberCenterPresent.MemberInfoChange,
        KKAccountManager.KKAccountChangeListener, View.OnClickListener {

其中BaseMvpActivity继承，而其他三个都是接口继承。

• java接口需要用implements关键字实现，而kotlin实现的方式和继承一样
• java接口能够直接通过匿名内部类创建出来，而kotlin也需要先将接口对象创建出来

when表达式

在kotlin中，用when表达式将将java中的switch替换掉了。
最简单的形式如下：

 override fun onClick(v: View?) {
       when (v?.id) {
           R.id.icBack -> finish()
           R.id.btnOpenLayout -> btnOpenLayoutClick()
           else -> {
           
       }
   }

而且，when里面的条件判断可以加入比较复杂的判断，如下：

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")
}

继承

kotlin中当含有非空的构造函数得继承，有以下这几种方式：

class MemberCenterAdapter(context: Context?, mixFindInfoList: ArrayList<MixFindInfo>?) : TopicTabListAdapter(context, mixFindInfoList) 

相当于子类的构造器声明就放在了class的定义上，然后会对应父类相应的构造器。还有另外一种实现方式，主要用于多个构造器的声明。

constructor(context: Context?, mixFindInfoList: ArrayList<MixFindInfo>?): super(context, mixFindInfoList)

列表

列表元素访问

在kotlin中，推荐我们使用下标的方式来访问元素，就像在访问数组一样。

private var itemTypeList: ArrayList<Int> = ArrayList()
itemTypeList[2] = ITEM_TYPE_ACTIVITY

列表元素遍历

对于kotlin中的列表遍历，增加了许多遍历方式。最简单的如下所示:

//kotlin 
for (i in startIndex..mixFindInfoList!!.size )
//java
for(int i = startIndex; i < mixFindInfoList.size(); i++)

在kotlin中，推荐我们使用until的方式进行遍历，这样，我们处理起来也就像是在处理流一样。

// a until b表示从a到b进行遍历，并且将遍历的值传递给下游，
// map将上游传递过来的值进行转化，并传递给下游
// forEach对转化后的值进行处理
(startIndex until mixFindInfoList!!.size)
                .map { mixFindInfoList[it] }
                .forEach {
                    itemTypeList.add(it.item_type)
                }

三目运算符

之前在java中用惯了三目运算符，看着kotlin的三目运算符挺不习惯的。

//java, 如果a为true，则取b，否则取c 
a ? b : c
//kotlin, 利用if else组成三目运算符，但是不需要括号
if(a) b else c

函数中流程语句的返回值

在kotlin中，如果多个分支语句都返回值，那么我们可以将返回值放在分支语句的外侧。

//最原始的版本
when (position) {
    0, 2 -> return null
    1 -> return Utility.getSafely(mixFindInfoList, 0)
    else -> {
        return Utility.getSafely<MixFindInfo>(mixFindInfoList, position - 2)
            }
                }

优化后的版本：

return when (position) {
    0, 2 -> null
    1 -> Utility.getSafely(mixFindInfoList, 0)
    else -> {
    Utility.getSafely<MixFindInfo>(mixFindInfoList, position - 2)                }
                }

这种时候，就能够返回每一个when分支对应的值
对于if else语句也能这么使用

 return if (activityListExist()) {
            if (vipBannerExist()) {
                when (position) {
                    0, 2 -> null
                    1 -> Utility.getSafely(mixFindInfoList, 0)
                    else -> {
                        Utility.getSafely<MixFindInfo>(mixFindInfoList, position - 2)
                    }
                }
            } else {
                if (position == 0 || position == 1) {
                    null
                } else {
                    Utility.getSafely<MixFindInfo>(mixFindInfoList, position - 2)
                }
            }
        } else {
            if (position == 0) {
                null
            } else {
                Utility.getSafely<MixFindInfo>(mixFindInfoList, position - 1)
            }
        }
    }

这种时候，每一种判断的分支对应一个值，返回命中的分支对应的值

类型判断和类型转换

java中类型判断和转化:

if (holder instance of MemberVipHeaderHolder) {
    ((MemberVipHeaderHolder)holder).bindData(title, TYPE_VIP_HEADER, isVip, isBtnShow);
}

java中利用instance of进行类型判断，然后直接通过(type)instance进行类型强转，将instance转化为type类型的实例。如果instance不是type类型，那么将会抛出类型转化异常。
而在kotlin中，可以通过as和is关键字进行类型判断和转化

override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
        when (getItemViewType(position)) {
            ITEM_TYPE_ACTIVITY -> {
                if (holder is MemberAssignViewHolder) {
                    holder.bindData(activityList)
                }
            }
            ITEM_TYPE_MEMBER_INFO_CARD -> {
                if (holder is MemberInfoCardViewHolder) {
                    holder.bindData()
                }
            }
            else -> {
                holder.itemView.setPadding(0, 0, 0, if (position == itemCount - 1) UIUtil.dp2px(40f) else 0)
                if (holder is BaseViewHolder) {
                    holder.holderType = BaseViewHolder.TYPE_MEMBER
                }
                super.onBindViewHolder(holder, position)
            }
        }
    }

利用 a is type 来判断a是否是type类型，如果是type类型的话，那么kotlin将会自动为我们将a转化为type类型，而不需要我们再手动的利用as进行类型转化。如果kotlin直接利用as进行类型转化的话，如果类型不一致或者a为null时，也会抛出异常，但是kotlin提供了类型不一致时的安全转化，如下

val x: String ?= y as? String

上面的例子中，as?是一个安全转化符，如果失败，将会返回null，而不会直接进行类型转化。

lambda

在java中，需要升级到java8才支持lambda表达，而kotlin天生支持lambda表达式，lambda表达式的完成语法如下:

val sum = { x: Int, y: Int -> x + y }

上面的例子定义了一个函数，求得sum = x + y,lambda表达式总是括在大括号中，完整的参数声明和表达式都放在大括号内，函数体在->之后，->之前都是参数，并且可能有类型标注，如果推断出该lambda的返回值类型不是Unit，也就是返回值不为空，那么该lambda主体的最后一个表达式将被视为返回值
下面是某一个lambda的例子：

FindExchangeManager.getInstance().loadExchangeData(mContext, findInfo.discoveryModuleId,
                    holder.adapterPosition, findInfo, FindExchangeManager.ExchangeCallback { data, position, discoveryModuleId ->
                if (Utility.isEmpty(mContext)) {
                    return@ExchangeCallback
                }

                val info = getMixInfoFromPosition(position)
                if (data != null && info != null) {
                    info.topics = data
                    notifyItemChanged(position)
                }
            })

如果在lambda表达式中调用return，将会直接return掉整个上层函数，因为lambda表达式只是一个代码块，虽然看起来功能像是函数，不过也不能说在lambda表达式中不能够return，只要给return指定一个标签，就会结束掉标签所指定的代码块，就像上面的例子，这个lambda表达式是在ExchangeCallback中使用的，如果要结束这个lambda，那么只需要在lambda中return代码添加上@ExchangeCallback标签就行，就绘结束掉ExchangeCallback的这个方法。

ViewHolder中使用kotlin extension

kotlin extension的使用需要先导入相应的xml

//在上一篇的activity中
import kotlinx.android.synthetic.main.activity_member_center.*

//在这个viewHolder中
import kotlinx.android.synthetic.main.listitem_assign.view.*

对于这个导包操作，需要注意的是，kotlinx.android.synthetic.main是固定前缀，后面的是当前页面的layout文件名称，如果是activity，只需要再在后面添加上.*，那就能够在activity中直接以id的形式调用对应的View。如果是在viewHolder中，那么还需要添加上.view,在添加.*才能够使用，而且在viewHolder中，需要以其itemView为持有者来调用。

init {
        context = itemView.context
        itemView.btn_get_gift.setOnClickListener(this)
        itemView.btn_not_gift.setOnClickListener(this)
    }

如上所示，利用itemView来持有其中的view的id，并直接调用。
这个init块，通常都是来做类的初始化的，在构造器执行完之后，会调用这个init块，我们如果有什么需要做初始化的，只需要放在这个init块中

String 转其他类型

java中String转long类型的话，需要调用Long.paras(string)进行转化，如果string不是相应的的类型，那么将会抛出异常。而在kotlin中也有这个方法，不过还新增了几个转化的方法：

//如果string不是一个合法的类型，那么将会抛出异常NumberFormatException
string.toLong()

//如果string不是一个合法的类型，那么将会返回null
string.toLongOrNull()

结合rxjava

kotlin中有专门的rx-kotlin库，刚开始并没有引入这个库，所以尝试着还是使用rxjava

Observable.timer(getDelayTime(), TimeUnit.MILLISECONDS)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe({
                    getGrabResult(activityId, thirdId)
                })

还是一样的用法，不过好的一点是可以使用lambda表达式了，subscribe({})中间的花括号就是lambda表达式

todo标注

在java中，使用todo标识并不会出现什么问题，在kotlin中，一旦我们实现了接口或者抽象类，那么我们自动生成的实现方法，将会带上kotlin的todo标注

override fun refreshServerTime(time: Long?) {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }

如果我们没有删除掉todo这行代码，那么kotlin将会直接报错，kotlin.NotImplementedError，因为这个todo是kotlin默认我们将会删除掉的，如果在运行时还存在，那么执行到todo，并不会跳过，而是会执行，然后报错。

kotlin标注

在kotlin中，如果需要在kotlin的高阶函数表达式返回，而不需要直接在外层函数中返回，或者嵌套循环，想从内层循环终止外层循环等，这种时候我们就需要用到kotlin的label了。比如说下面的例子：

private fun canAutoContinue(pos: Int): Boolean {
        if (commonGoodList == null || continueGoodList == null || commonGoodList!!.size < pos) {
            return false
        }
        val commonGood: RechargeGood? = commonGoodList!![pos]

        continueGoodList!!.forEach {
            if (it.upRenewId == commonGood?.id) {
                return true
            }
        }
        print("1111")
        return false
    }

上面的在forEach中，return的执行将会直接将会结束掉canAutoContinue方法，如果我们只想结束掉forEach，我们可以像下面这样做。

private fun canAutoContinue(pos: Int): Boolean {
        if (commonGoodList == null || continueGoodList == null || commonGoodList!!.size < pos) {
            return false
        }
        val commonGood: RechargeGood? = commonGoodList!![pos]

        continueGoodList!!.forEach lit@{
            if (it.upRenewId == commonGood?.id) {
                return@lit
            }
        }
        print("1111")
        return false
    }

如上面的lit label，那么这样return将会结束lit所指定的lable循环，从而继续往下执行。
比如说for循环嵌套

outFor@ for(x in 1..5) {
            for (y in 1..6) {
                if(x == y) {
                    break@outFor
                }
            }
        }

一旦满足了x==y，然么将会直接跳出外层的for循环，否则一般的break，只会中断内层的for循环。要为一个表达式加标签，我们只要在其前加标签即可。
在返回和跳转语句中，可以指定标签来表示结束哪个标签对应的代码段
如果需要在lambda表达式

kotlin 定义属性时的get和set方法

kotlin定义属性时，可以同时定义get和set方法，而不需要再重新定义方法去赋值。

private var delayTime: Long
        private set(value) {
            delayTime = value
        }
        get() {
            return KKConfigManager.getInstance().
                    getConfig(KKConfigManager.ConfigType.GET_RECHARGE_ORDER_DELAY)
                    .toLongOrNull() ?: 1000
        }

而且，可以添加上访问限定符。而这个get和set方法的设置，主要是通过代码中的位置来标示修饰的哪个变量。

kotlin的幕后字段

Kotlin 中的类不能有字段， 然而我们在有时在自定义访问器时，也就是get和set方法时，需要又一个幕后字段，这个字段是kotlin提供的，field,我们可以直接使用。

var counter = 0 // 注意:这个初始器直接为幕后字段赋值 set(value) {
if (value >= 0) field = value }


val nameHash:Int = 3
        get() {
            field = 5
            return 10
    }

有可能我们需要临时缓存变量的值，因为可能其变量的值可能和返回的值不一致，所以一旦我们需要知道变量的值，我们便可以通过幕后字段来访问。

kotlin的幕后属性

幕后属性主要用于外部只能读，内部可以读写的需求下出现的。例如下面的例子：

val counter get() = _counter
private var _counter = 0

这个_counter就是counter的幕后属性，外部只能访问counter，不能访问_counter，而counter的值又是_counter来指定的。

kotlin的扩展

在kotlin中，if else的三目运算符如下所示:

if(a) x else y

而我们也能通过扩展函数来扩展boolean

inline fun <T> Boolean.yes(action: () -> T): Boolean {
    if (this) action()
    return this
}

inline fun <T> Boolean.no(action: () -> T): Boolean {
    if (!this) action()
    return this

这样，我们在kt文件中，只要引入相应的类，定义在文件内，而非class下

import com.kuaikan.community.extend.yes

扩展函数是静态解析的，所以不能够进行重载，这就意味着我们，我们不能重载类原有的方法，比如说collection的add方法等…
对于扩展函数还有一个非常好用的东西，被扩展的类型可以为空，被称为可空接收者

fun Any?.toString(): String {
if (this == null) return "null"
// 空检测之后，“this”会自动转换为非空类型，所以下面的 toString() // 解析为 Any 类的成员函数
return toString()
}

kotlin的扩展属性

既然kotlin支持扩展函数，当然也支持扩展属性了。

 val <T> List<T>.lastIndex: Int
    get() = size - 1

这样就给了List的一个属性lastIndex

kotlin的范型

关于out和in这两个关键字，out是用来输出的，也就是生产者，所以只能作为返回类型，相当于java中的extends，用来界定类型上限；in是用来输入的，所以只能作为消费类型，in类似于java中的super，用来界定类型下限

kotlin的单例

在kotlin中，声明单例变得非常简单，只需要一个关键字object用来修饰对象，就像变量声明一样，对象声明不是一个表达式，不能用在赋值语句右边，对象的初始化是线程安全的。如果需要引用该对象，我们只需要通过其名称来调用。

object DataProviderManager {
fun registerDataProvider(provider: DataProvider) {
// ......
}
val allDataProviders: Collection<DataProvider> get() = // ......
}

//调用
DataProviderManager.registerDataProvider(......)

伴生对象

类内部的伴生对象的声明如下：

class MyClass { 
    companion object { }
}
val x = MyClass.Companion

请注意，即使伴生对象的成员看起来像其他语言的静态成员，在运行时他们仍然是真实对象的实例成员，而且，例如还可以实现接口:

interface Factory<T> { fun create(): T
}
class MyClass {
companion object : Factory<MyClass> {
override fun create(): MyClass = MyClass() }
}

如果我们想将伴生对象的成员生成为真正的静态方法和字段，我们我们可以使用@JvmStatic注解

对象表达式和对象声明之间的语义差异

对象表达式和对象声明之间有一个重要的语义差别:

• 对象表达式是在使用他们的地方立即执行(及初始化)的;
• 对象声明是在第一次被访问到时延迟初始化的;
• 伴生对象的初始化是在相应的类被加载(解析)时，与 Java 静态初始化器的语义相匹配。

onAttachedToWindow和onDetachedFromWindow

这个是无关kotlin的，只是刚好在写kt代码时遇到的一个问题，
关于onAttachedToWindow和onDetachedFromWindow的触发时机，

onAttachedToWindow就是在这个View被添加到Window时触发的

顾名思义，onAttachedToWindow就是在这个View被添加到Window时触发的，通过了dispatchAttachedToWindow这个方法触发的，那么View被添加到window的时机又是什么，其实就是对应的activity在生命周期onResume的时候调用的，activity对应的view在onResume的时候被添加添加到window。且每一个view都只会被调用一次，父view调用在前，不论view的visibility状态都会被调用，适合做些view特定的初始化操作；

onDetachedFromWindow

onDetachedFromWindow方法是在activity的生命周期destroy的时候被调用的，也就是act对应的view从window中移除的时候，且每个view只会被调用一次，父view的调用在后，也不论view的visibility状态都会被调用，适合做最后的清理操作；

kotlin类的继承性

java的class默认都是可以继承的，只有在声明为final的class才是不可继承的。而kotlin却是相反的，默认的类都是不可继承的，也就是默认的修饰符为final，只有显式的声明为open的类才是可以继承的。而对于抽象类，java和kotlin默认都是可以继承的，但是子类必须是抽象类或者实现了该类的所有抽象方法。

kotlin扩展函数的java调用方式

kotlin中的扩展函数是非常方便的，刚开始以为在java中不能够调用到kotlin中的扩展函数，后面发现不是的，对于我们定义的扩展函数类，在java中有相应的使用方式

//KotlinExt.kt
fun Int.dp2px(context: Context?): Int {
    val scale = context?.resources?.displayMetrics?.density?.toInt()
    return (this * (scale ?: 2) + 0.5f).toInt()
}
//java中调用
KotlinExtKt.dp2px(2, getContext());

我们只需要import相应的kotlinExt文件，然后就可以调用其中的方法，但使用方式和kotlin有不一致的地方，对于kt的扩展函数的接收者，也就是上面的Int，在java中会被认为是第一个入参， 如果扩展函数接受的是普通参数，那么这个参数就直接作为后续的入参。
如果扩展数据的第二个参数是lambda表达式，那么有java相应的生成方式：

//KotlinExt.kt
inline fun <T> Boolean.yes(action: () -> T): Boolean {
    if (this) action()
    return this
}
//java中调用
KotlinExtKt.yes(true, new Function0<Object>() {
                    @Override
                    public Object invoke() {
                        return null;
                    }
                });

上面的Boolean的扩展yes方法，接收一个高阶函数，kt中用lambda表示，而在java中，需要以一个匿名内部类的方式替代，

kotlin中内部类

在java中，如果定义一个非静态类内部类，默认将会持有外部类的引用，经常会造成外部类无法被回收，导致内存泄漏，而kotlin中，内部类默认不会持有外部类的引用，只有添加上inner关键字修饰，才会持有外部引用。

kotlin 密封类

kotlin的密封类是java所没有的，在kotlin中，如果一个类被标明为密封类，那么其所有的子类都需要在父类中列出，作为密封类的嵌套内部类

kotlin中的惰性集合操作

kotlin中一些集合操作，比如说map和filter，对于我们来说是非常方便的，比如说筛选一个人群的年龄大于30的人的名称。

people.map(it.name).filter{it.age > 30}

但是上面这种方式，在链式调用的链足够长时，将会产生性能问题，因为链式调用的每一个步骤都会创建一个中间集合，用来存储中间结果，也就是说，每一个步骤的结果都存储在另外一个变量中。所以，kotlin给我们提供了另外一种使用方式，来避免创建中间对象。也就是惰性集合。sequencez作为惰性集合操作，可以优化map和filter等操作，将不会生成任何中间对象

people.asSequence().map(people.name).filter(it.startWith("a")).toList()

sequencez会将元数据生成一个流式对象，对于集合的每一个元素利用iterator遍历，执行map和filter，筛选出符合条件的数据。
惰性集合的操作包含了中间操作和末端操作，中间操作就是转换操作，末端操作就是筛选操作，在上面的例子里面，map是中间操作，filter是末端操作，如果没有末端操作，那么，中间操作也不会执行，既然这样，如果我们末端操作停止了，中间操作也会停止，也就是说，并不会保证所有的中间操作都能够执行。

butterknife库的使用

在java中，butterknife库是一个众所周知的代替findViewId操作的库，如果我们直接在kotlin中想要使用butterknife这个库，那还是需要一些额外的操作的。

引入KotterKnife或者自己提供extension

这个是butterknife作者提供的另外一个kotlin版本的替代库。使用方式如下:

val updateTime by bind<TextView>(R.id.update_time)

虽然我没看KotterKnife内部实现，但是应该跟我们自己提供扩展函数的实现方式是一样的，我们可以通过自己提供扩展函数来设置做这些操作：

fun <T : View> Activity.bind(@IdRes idRes: Int): Lazy<T> {
    return lazy { findViewById<T>(idRes) }
}

fun <T : View> View.bind(@IdRes idRes: Int): Lazy<T> {
    return lazy { findViewById<T>(idRes) }
}

fun <T : View> android.support.v7.widget.RecyclerView.ViewHolder.bind(@IdRes idRes: Int): Lazy<T> {
    return lazy { this.itemView.findViewById<T>(idRes) }
}

fun <T : View> Fragment.bind(@IdRes idRes: Int): Lazy<T?> {
    return lazy { this.view?.findViewById<T>(idRes) }
}

这个扩展数据其实就是代替我们执行findViewById操作，虽然我们是在初始化的时候定义了View的对象，但是它并不会马上执行，lazy关键字修饰的对象将会等到使用时再执行相应方法。也就是说，这个findViewById将会在setContentView之后执行，因为我们使用这个对象肯定是在其之后的。

仍然使用butterknife

其实在kotlin中，我们还是可以使用butterknife的，只是我们需要将butterknife的注解解释器替换为kotlin annotation Processor tool，这样，在kt文件中就能够使用butterknife的注解了，我们不需要担心会对之前的注解产生影响，因为kapt是兼容了annotationProcessor的。

annotationProcessor 'com.jakewharton:butterknife-compiler:8.4.0'
====>
kapt 'com.jakewharton:butterknife-compiler:8.4.0'

替换了kapt之后，就可以进行第二步了,在kt中利用laterinit修饰对象，来保证view对象可以在通过butterknife库赋值

 @BindView(R.id.user_v_layout)
    lateinit var vLayout: ImageView
    @BindView(R.id.comment_user_icon)
    lateinit var userIconIV: ImageView
    @BindView(R.id.comment_user_name)
    lateinit var userNameTV: TextView