java 中的方法或变量 是 kotlin 的关键字时,使用反引号 `` 对关键字进行转义
// java
public class JavaDemo {
String is;
public String getIs() {
return is;
}
public void setIs(String is) {
this.is = is;
}
public void in() {
System.out.println("call java method in");
}
public void multiParams(int... params) {
System.out.println(Arrays.toString(params));
}
}
// kotlin
fun main() {
// 1. java 中的方法或变量 是kotlin 的关键字时,使用反引号 `` 对关键字进行转义
val demo = JavaDemo()
// 调用 java 的 is 属性,is 是 kotlin 的关键字,使用反引号转义
demo.`is` = "call java field"
println(demo.`is`) // call java field
// 调用 java 的 in 方法,in 是 kotlin 的关键字,使用反引号转义
demo.`in`() // call java method in
}
// kotlin
// 使用 * 号将 kotlin 的 数组 传给 java 的 可变数量参数
fun main() {
val arrayInt = intArrayOf(1, 2, 3)
demo.multiParams(*arrayInt) // [1, 2, 3]
}
// kotlin
fun main() {
demo::class.java
demo.javaClass
}
// kotlin
class KotlinDemo {
var field: String = "kotlin field"
fun method() {
println("call kotlin method")
}
}
// java
public static void main(String[] args) {
KotlinDemo demo = new KotlinDemo();
System.out.println(demo.getField()); // kotlin field
demo.method(); // call kotlin method
}
// kotlin
val topLevelField: Int
get() {
println("call kotlin top level field")
return 1
}
fun topLevelFunc() {
println("call kotlin top level function")
}
// java
public static void main(String[] args) {
TestCallEachOtherKt.getTopLevelField(); // call kotlin top level field
TestCallEachOtherKt.topLevelFunc(); // call kotlin top level function
}
// kotlin
// 指定文件生成的 Java 类或方法的名称。
@file:JvmName("CallKtDemo")
package com.william.testkt
var field: Int = 100
fun method() {
println("call CallKtDemo method")
}
// java
public static void main(String[] args) {
System.out.println(CallKtDemo.getField());
CallKtDemo.method();
}
// kotlin
class TestCallKotlin {
companion object {
// 模拟静态方法
fun method1() {
println("call method1")
}
// 静态方法
@JvmStatic
fun method2() {
println("call method2")
}
}
}
// java
public static void main(String[] args) {
TestCallKotlin.Companion.method1();
TestCallKotlin.method2();
}
// kotlin
object KotlinObject {
fun method1() {
println("call method1")
}
@JvmStatic
fun method2() {
println("call method2")
}
}
// java
public static void main(String[] args) {
KotlinObject.INSTANCE.method1();
KotlinObject.method2();
}
当在 java 中赋值 kotlin 的 lambda 表达式时,用 FunctionN 指代,N:表达式入参的数量,尖括号最后一个类型:表达式返回值的类型
// kotlin
object KotlinObject {
// 参数为 lambda 表达式,入参为 Int,返回值为 Unit,在定义时,也可以不写等号后面的表达式
@JvmStatic
fun method3(param: (Int) -> Unit = {}) {
param.invoke(101)
}
// 参数为 lambda 表达式,入参为 Boolean,返回值为 String,在定义时,也可以不写等号后面的表达式
@JvmStatic
fun method4(param: (Boolean) -> String = { "" }) {
param.invoke(true)
}
// 参数为 lambda 表达式,无入参,返回值为 Unit
@JvmStatic
fun method5(param: () -> Unit) {
param.invoke()
}
// 参数为 lambda 表达式,入参为 Int, String,返回值为 Boolean
@JvmStatic
fun method6(param: (Int, String) -> Boolean) {
param.invoke(100, "string value")
}
}
// java
public static void main(String[] args) {
// 参数为 lambda 表达式,入参为 Int,返回值为 Unit
KotlinObject.method3(new Function1<Integer, Unit>() {
@Override
public Unit invoke(Integer integer) {
System.out.println(integer);
return null;
}
});
// 参数为 lambda 表达式,入参为 Boolean,返回值为 String
KotlinObject.method4(new Function1<Boolean, String>() {
@Override
public String invoke(Boolean param) {
System.out.println("invoke param: " + param);
return param ? "success" : "failed";
}
});
// 参数为 lambda 表达式,无入参,返回值为 Unit
KotlinObject.method5(new Function0<Unit>() {
@Override
public Unit invoke() {
System.out.println("invoke method5 no params");
return null;
}
});
// 参数为 lambda 表达式,入参为 Int, String,返回值为 Boolean
KotlinObject.method6(new Function2<Integer, String, Boolean>() {
@Override
public Boolean invoke(Integer integer, String s) {
System.out.println("invoke method6 params:integer=" + integer + ", s=" + s);
return integer > 0;
}
});
}
对于有默认值的函数或方法,可以使用 @JvmOverloads 注解强制生成多个重载方法,以方便其在 java 中调用
// kotlin
class KotlinDemo {
/**
* @JvmOverloads 注解会生成以下重载方法:
* 当参数有默认值时,会生成对应的重载方法。注意 p0 没有默认值
*
* void overloadMethod1(int p0)
* void overloadMethod1(int p0, int p1)
* void overloadMethod1(int p0, int p1, String p2)
*/
@JvmOverloads
fun overloadMethod1(p0: Int, p1: Int = 1, p2: String = "") {
}
/**
* @JvmOverloads 注解会生成以下重载方法:
*
* void overloadMethod2()
* void overloadMethod2(int p0)
* void overloadMethod2(int p0, int p1)
* void overloadMethod2(int p0, int p1, String p2)
*/
@JvmOverloads
fun overloadMethod2(p0: Int = 0, p1: Int = 1, p2: String = "") {
}
}
// java
public static void main(String[] args) {
KotlinDemo demo = new KotlinDemo();
// 调用 kotlin 的重载方法
demo.overloadMethod1(0);
demo.overloadMethod1(0, 1);
demo.overloadMethod1(0, 1, "p2");
// 调用 kotlin 的重载方法
demo.overloadMethod2();
demo.overloadMethod2(0);
demo.overloadMethod2(0, 1);
demo.overloadMethod2(0, 1, "p2");
}