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

Posted 颐和园

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了深入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,抛出异常。同时这个方法不会被调用。

以上是关于深入kotlin - 与Java互操作:java调用kotlin的主要内容,如果未能解决你的问题,请参考以下文章

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

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

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

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

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

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