【深入kotlin】 - 与Java互操作：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"
  
  

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

  伴生对象

  假设定义一个伴生对象：

  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 = HelloKitlin.myFilter(new ArrayList<>()); // 1
    List<Integer> list2 = HelloKitlinKt.myFilter2(new ArrayList<>()); // 2
  }
  

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

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

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