深入kotlin - 与Java互操作：java调用kotlin

Posted 2023-02-21 颐和园

Java 调用 kotlin

属性

Kotlin 类的一个属性编译后，会产生 3 种 Java 对象：

• get 方法，getXxx
• set 方法，setXxx
• 私有字段，字段名与 kotlin 属性名完全匹配。

class Test 
	var name: String = ""

如果 kotlin 属性名为 is 开头（Bool 类型），get 方法名 = 属性名，set 方法名则是将 is 替换为 set，字段名=属性名。

@JvmField 注解

当对 kotlin 属性使用该注解修饰后，这个属性就变成一个实例变量（public），kotlin 编译器不会生成 get/set 方法。在 java 中直接通过字段名进行访问。

顶层对象

Kotlin 顶层对象会编译成静态成员、静态方法。类名是文件名+Kt。假设有一个 MyClass.kt 文件：

fun test() 
	println("test 方法")

var name:String = "zhangsan"

在 java 中：

public static void main(String[] args) 
  MyClassKt.setName("Joy");
  MyClassKt.test();// 打印：test 方法
  System.out.println(MyClassKt.getName());// 打印：Joy

但是 MyClassKt 无法直接实例化（运行时异常）。因为在生成的字节码中没有提供不带参的构造方法（也没有其他形式的构造方法）。

修改默认命名

一个 kotlin 源文件默认会编译出一个 java 类，类的命名默认是文件名+Kt。我们可以在文件第一行使用 @JvmName 注解修改默认的命名方式：

@file: JvmName("HelloWorld")
fun myPrint() 
	println("myPrint")

var name:String = "zhangsan"

但是同一包下， JvmName 不能重复。如果要将多个文件都命名为同一类名，需要使用 JvmMutilfierClass 注解(每个文件都需要)：

@file: JvmName("HelloWorld")
@file: JvmMultifileClass
fun myPrint() 
	println("myPrint")

var name:String = "zhangsan"

最终生成的字节码将是所有文件合并后的结果。

伴生对象

假设定义一个伴生对象：

class People 
	companion object 
		var name = "Joe"
    @JvmField				// @JvmField 修饰伴生对象的属性，会将伴生对象的属性变成 People 的公有字段
		var age = 20
	

在 java 中如何访问：

System.out.println(People.Companion.getName());// 通过 Companion 来访问伴生对象
System.out.println(People.age);// 访问修饰伴生对象的 JvmField 属性

kotlin 中，可以将伴生对象中的方法：

class MyClass 
	companion object 
		fun test1()
			println("test1")
		
		fun test2()
			println("test2")
		
	

在 java 中调用伴生对象的方法：

MyClass.Companion.test1();
MyClass.Companion.test2();

Companion 实际上是 MyClass 的内部类 MyClass$Companion。这两个方法位于 Companion 中。通过注解可以改变这一行为：

		@JvmStatic // @JvmStatic 会在 MyClass 中生成静态方法 test2，也会在 Companion 内部类中生成实例方法 test2
		fun test2()
			println("test2")
		

这样就可以在 Java 中以两种方式调用 test2 方法：

MyClass.Companion.test2();
MyClass.test2();

@JvmName 注解

此注解可用于解决 kotlin 在字节码层级上的命名冲突。

扩展函数的命名冲突

假设定义如下扩展函数：

fun List<String>.myFilter(): List<String> 
	return listOf("hello","kotlin")

fun List<Int>.myFileter(): List<Int> 
	return listOf(1,2)

上述代码编译器报错，说：两个扩展函数拥有相同的 JVM 方法签名：myFilter(Ljava/util/List;) Ljava/util/List;。你可能会奇怪 myFilter 方法在编变成字节码后，为什么后会多出一个 List 类型的参数？那是因为扩展函数在编译成字节码时，会将被扩展的类作为方法的第一个隐藏参数。

其次，Java 的范型也不是真正的范型，范型信息并不会存储进字节码中（类型擦除）。所有的范型在字节码中会做一个强制的向下类型转换。比如 List<String>在字节码中都统一变成 List<Object>，只不过在访问其中的元素时，会进行一个额外的强转为 String 的操作。

在这种情况下，两个 myFilter 的签名显然相同了，二者存在命名冲突。如果一定要让二者并存，需要用到一个 JvmName 注解：

fun List<String>.myFilter(): List<String> 
	return listOf("hello","kotlin")

@JvmName("myFilter2")
fun List<Int>.myFilter(): List<Int> 
	return listOf(1,2)

这样，第二个函数名在编译出字节码时会被修改为 myFilter2，从而消除了命名冲突。同时在 Java 中调用也会变成：

public static void main(String[] args) 
	List<String> list = HelloKotlinKt.myFilter(new ArrayList<>()); // 1
  List<Integer> list2 = HelloKitlinKt.myFilter2(new ArrayList<>()); // 2

1. Java 中并没有扩展的概念，因此用静态方法的方式来调用 myFilter()，因为这个函数是定义在 HelloKitlin.kt 这个文件的包级别（顶层对象）。此外，如之前所说，这个函数的第一个参数是一个隐藏参数，参数类型就是被扩展的类，因此需要传递一个 List 对象给它（List 是接口，不能实例化，因此用 ArrayList 替代）。
2. 至于第二个扩展方法，只能用 myFilter2 来调用了，否则 Java 不能识别。

如果直接在 Kotlin 中调用就简单得多了：

val list = listOf<String>() // 1
println(list.myFilter())
val list2 = listOf<Int>() // 2
println(list2.myFilter())

1. 在 List 上调用 myFilter
2. 在 List 上调用 myFilter。此时反而不能用 myFilter2 调用了，因为 @JvmName 注解是专门用于 Java 的，对 Kotlin 是无效的。

get/set 方法的命名冲突

此注解用于修改 kotlin 编译成字节码时属性的默认 get 方法名。例如：

class MyClass 
	val a: Int
		get() = 20
	fun getA() = 30

MyClass 的属性 a 在编译成字节码时，将生成一个 get 方法，默认名为 getA()，这显然和 MyClass 的已有方法命名冲突了。此时就可以用上 JvmName 注解：

class MyClass 
	val a: Int
		@JvmName("getAProperty")
		get() = 20
	fun getA() = 30

这样在字节码中， a 的 get 方法就变成了 getAProperty()。在 Java 中用此名称来访问 a 属性 ：

public static void main(String[] args)
	MyClass myClass = new MyClass();
  System.out.println(myClass.getAProperty()); // 输出：20
  System.out.println(myClass.getA()); // 输出：30

同样地， JvmName 注解对 kotlin 无效：

val myClass = MyClass()
println(myClass.getA()) // 30
println(myClass.a) // 20

@JvmOverloads 注解

Java 中不存在方法默认值的概念。那么假设有一个带默认值的 kotlin 方法：

class MyClass constructor(x:Int, y: String = "abc") 
	fun method(a:Int, b: String, c: Int = 2) 
		 println("a: $a, b: %b, c: $c")
	

在 Java 中如何调用？

public static void main(String[] args) 
	MyClass myClass = new MyClass(1); 
	

此时，编译器报错，找不到构造方法 MyClass(Int)。很显然 MyClass 并不存在只带有一个参数的构造方法，虽然我们为第二个构造参数设定了默认值，但是 Java 中并没有参数默认值的概念。此时就需要用到 JvmOverloads 注解：

class MyClass @JvmOverloads constructor(x:Int, y: String = "abc") 
	@JvmOverloads fun method(a:Int, b: String, c: Int = 2) 
		 println("a: $a, b: %b, c: $c")
	

这样，kotlin 编译器将会为我们的构造方法生成若干个重载方法，比如：

MyClass(int x, String y)

MyClass(int x)

这样，前面的 new MyClass(1) 就不会再报错了。

@Throw 注解

Java 将异常分为 checked exception 和 uncheck exception。其中，checked exception 是必须被 catch 的异常，通常这些异常都是由 throw 语句抛出的异常，编译器会强制要求开发者进行 catch。

而 unchecked exception 是程序员不可以预料的异常，不需要 catch。比如空指针异常和内存溢出异常。

但是 kotlin 中，并不存在 checked exception 的概念，因此对异常的处理，kotlin 和 java 有截然不同的处理方式。

如果在 kotlin 中 throw 了一个 exception:

class MyClass 
	fun method()  // 注意与 Java 不同，不需要在方法名后面加 throws FileNotFoundException
		println("method invoked")
		throw FileNotFoundException() // 在 java 中，这是一个 checked exception, 继承自 IOException -> Exception
	

如果 kotlin 调用这个方法，不强制对这个异常进行任何 catch。但是在 java 中，由于方法没有声明为 throws，所以 java 在调用时仍然可以不用 catch：

public void main(String[] args)
	MyClass myClass = new MyClass();
	myClass.method(); // java 不能正确识别这里会抛出一个 checked exception，因此编译器会通过

但这样就会导致异常往上抛出，导致程序崩溃。正常的做法是对 myClass.method() 一句进行 try…catch 包裹。但实际上这样会导致 java 编译器抱怨“method 方法不会抛出异常”，因为 method 方法是一个 kotlin 方法，不能被识别为 throws 方法。要解决这个问题，需要用到 @Throws 注解：

	@Throws(FileNotFoundException::class)
	fun method()  
		println("method invoked")
		throw FileNotFoundException() 
	

这会在字节码中为方法生成 throws 声明，从而让 java 能正常 try…catch:

public void main(String[] args)
	MyClass myClass = new MyClass();
	try
		mayClass.method();
	catch(FileNotFoundException e)
		ex.printStackTrace();
	
	System.out.println("....")

这样程序不会崩溃，后面的代码仍然能够执行。

Optional 可空

因为 kotlin 对类型检查比 java 更为严格，比如你不能将一个 null 传递给一个非 optional 对象。这就对 java 调用 kotlin 代码带来了挑战。因为 java 中没有非空检查，很有可能会将一个 null 传递给一个 kotlin 方法对非 optional 参数。

在这个 kotlin 方法中，str 参数是非空的：

class MyClass 
	fun method(str: String) 
		println("method invoked")
		println(str)
	

在 Java 中调用它：

public static void main(String[] args)
	MyClass myClass = new MyClass();
	myClass.method(null);

代码编译通过，但运行时出现崩溃，报错：

IllegalArgumentException：Parameter specified as non-null is null

这说明 JVM 在调用 method 前对参数进行了非空检查，如果发现对非 optional 参数传递了 null，抛出异常。同时这个方法不会被调用。