Android Kotlin大全

常用函数

let

Kotlin为了空安全不允许定义为空的，想要定义的话就必须加上问号。

//可以为空
var name: String? = null
//不可以为空，初始化为test
var name2: String = "test"
//不可以为空，不做初始化
lateinit var name3: String

with

这个标准函数的作用是Lambda中的代码会持有对象的上下文，其最后一行代码为返回值。

    fun testWith(n: Int): String {
    val sb = StringBuilder()
    repeat(n) {
        sb.append(n)
    }
    return sb.toString()
}

run

这个标准函数的作用其实和 with 基本一致，只是使用方法上有所不同，with 需要括号中写入对象来进行操作，run 则是对象点进行操作。

fun testRun(n: Int): String {
    return StringBuilder().run {
        repeat(n) {
            append(n)
        }
        toString()
    }
}

apply

apply 使用方式和run一致，但是不同的是：最后一行不作为返回值。

fun showDialog(activity: Activity) {
    AlertDialog.Builder(activity).apply {
        setMessage("apply操作符测试")
        setCancelable(false)
        setPositiveButton("PositiveButton") { _, _ ->
            Toast.makeText(activity, "PositiveButton Click!", Toast.LENGTH_LONG).show()
        }
        setNegativeButton("NegativeButton") { _, _ ->
            Toast.makeText(activity, "NegativeButton Click!", Toast.LENGTH_LONG).show()
        }
        show()
    }
}

关键字

lateinit

确定一定不为空可以使用 lateinit 这个关键字来定义全局变量。

1
2
3

//不可以为空，不做初始化
lateinit var name3: String
lateinit var user: User

如果需要判断是否初始化，可以使用isInitialized方法。

fun testLet(){
    if (::user.isInitialized){
        // 判断是否已经进行赋值
    }
}

sealed

密封类，少写一个else，其他特性还不知道呢。

sealed class Result

class Success(val msg: String) : Result()
class Fail(val error: Throwable) : Result()

fun getResult(result: Result) = when (result) {
   is Success -> result.msg
   is Fail -> result.error.message
}

operator

运算符重载，可以对运算符进行重新自定义。

1
2
3

 operator fun String.times(n: Int): String {
    return "$this n:$n";
}

internal

限制不同 module 的访问，如果在 A module 中定义了一个 internal 方法，那么这个方法只能在 A module 中进行调用，在 B module 中是无法访问的。

inner

用来修饰内部类。

inline

内联函数，它的用法非常简单，只需要在高阶函数前加上 inline 关键字即可。

inline fun high(block:(Int,Int) -> Int,block2:(Int,Int) -> Int){
    block.invoke(5,6)
    block2.invoke(4,5)
}

noinline

指定参数为非内联函数。

1
2
3

inline fun high(block:(Int,Int) -> Int,noinline block2:(Int,Int) -> Int){
    block.invoke(5,6)
    block2.invoke(4,5)

infix

感觉用处不太大。

1	infix fun String.begin(prefix:String):Boolean = startsWith(prefix)

by

委托，可以为一些类创建委托类并重写或添加一些自己写的方法。

class MySet<T>(val help:HashSet<T>) :Set<T> by help{
    override fun isEmpty(): Boolean {
        return false
    }
}

泛型

不多数，跟java类似。

class Generic <T>{
    fun method(parem:T):T{
        return parem
    }
}
fun <S> meth(parem:S):S{
    return parem
}