kotlin与Java的相互调用

[appdev]

kotlin与Java的相互调用

构造函数

Kotlin 中类可以有一个主构造函数以及多个二级构造函数。主构造函数是类头的一部分：跟在类名后面(可以有可选的类型参数)。

class Person constructor(firstName: String) {
}

如果主构造函数没有注解或可见性说明，则 constructor 关键字是可以省略：

class Person(firstName: String){
}

主构造函数不能包含任意代码。初始化代码可以放在以 init 做前缀的初始化块内

class Customer(name: String) {
    init {
        logger,info("Customer initialized with value ${name}")
    }
}

二级构造函数

类也可以有二级构造函数，需要加前缀 constructor:

class Person {
    constructor(parent: Person) {
        parent.children.add(this)
    }
}

如果类有主构造函数，每个二级构造函数都要，或直接或间接通过另一个二级构造函数代理主构造函数。在同一个类中代理另一个构造函数使用 this 关键字：

class Person(val name: String) {
    constructor (name: String, paret: Person) : this(name) {
        parent.children.add(this)
    }
}

如果一个非抽象类没有声明构造函数(主构造函数或二级构造函数)，它会产生一个没有参数的构造函数。该构造函数的可见性是 public 。如果你不想你的类有公共的构造函数，你就得声明一个拥有非默认可见性的空主构造函数：

class DontCreateMe private constructor () {
}

匿名内部类

使用_对象表达式_创建匿名内部类实例

text.setOnClickListener(object : View.OnClickListener{
    override fun onClick(p0: View?) {
        Log.d("test", p0.string())
    }
})

Kotlin高阶函数

run 函数

不带 receiver 的 run 函数执行参数中的可执行对象，将返回值作为 run 的返回值：

/**
 * Calls the specified function [block] and returns its result.
 */
@(Kotlin)kotlin.internal.InlineOnly
public inline fun <R> run(block: () -> R): R = block()

带 receiver 的 run 将上下文中的 this 指向 receiver 并执行参数中的可执行对象，将返回值作为 run 的返回值：

/**
 * Calls the specified function [block] with `this` value as its receiver and returns its result.
 */
@kotlin.internal.InlineOnly
public inline fun <T, R> T.run(block: T.() -> R): R = block()

with 函数

换了个写法的带 receiver 的 run 函数：

/**
 * Calls the specified function [block] with the given [receiver] as its receiver and returns its result.
 */
@kotlin.internal.InlineOnly
public inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()

apply 函数

类似带 receiver 的 run 函数，可执行对象参数的执行上下文中 this 被设置为receiver。不同的是apply返回 receiver 本身。

/**
 * Calls the specified function [block] with `this` value as its receiver and returns `this` value.
 */
@kotlin.internal.InlineOnly
public inline fun <T> T.apply(block: T.() -> Unit): T { block(); return this }

apply 函数将处理过程“应用”到 receiver 上并返回 receiver 本身，这适用于修改 receiver 的场景，比如将某个函数的返回值修正一下。

let 函数

let 函数将 receiver 作为其可执行对象参数的实参传入并执行可执行对象，返回值是可执行对象的返回值：

/**
 * Calls the specified function [block] with `this` value as its argument and returns its result.
 */
@kotlin.internal.InlineOnly
public inline fun <T, R> T.let(block: (T) -> R): R = block(this)

结合it语法糖。一般来说在写传入 let 函数的Lambda表达式参数时往往使用 it 表示 let 的 receiver 。

also 函数

它和 let 函数的关系类似于 apply 和带 receiver的 run 函数的关系。also 函数将 receiver 作为其可执行参数的实参传入并执行可执行对象，但是其返回值为 receiver 本身

/**
 * Calls the specified function [block] with `this` value as its argument and returns `this` value.
 */
@kotlin.internal.InlineOnly
@SinceKotlin("1.1")
public inline fun <T> T.also(block: (T) -> Unit): T { block(this); return this }

kotlin中的线程安全单例

class DvLog {
    companion object {
        val instance by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
            DvLog()
        }
    }
}

在 Kotlin 中调用 Java 代码

与 Kotlin 关键字冲突的处理

Java 有 static 关键字，在 Kotlin 中没有这个关键字，需要使用@JvmStatic替代这个关键字。
同样，在 Kotlin 中也有很多的关键字是 Java 中是没有的。如 in,is,data等。如果 Java 中使用了这些关键字，需要加上反引号(`)转义来避免冲突。例如

// Java 代码中有个方法叫 is()
public void is(){
    //...
}

// 转换为 Kotlin 代码需要加反引号转义
fun `is`() {
   //...
}

Kotlin代码混淆

-dontwarn kotlin.**

-assumenosideeffects class kotlin.jvm.internal.Intrinsics {
    static void checkParameterIsNotNull(java.lang.Object, java.lang.String);
}