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

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，抛出异常。同时这个方法不会被调用。