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