kotlin(十七)Kotlin和Java相互调用

1.Kotlin调用Java的方法和属性

 1）定义java类

public class JavaClass {
    private String javaString = "java";
    public void sayHello(String name) {
        System.out.println("Hello " + name);
    }

    public String getJavaString() {
        return javaString;
    }

}

Kotlin调用Java.由于Java中可以定义null，所以在kotlin中要做可空性判断，避免发生空指针异常

fun main() {
    val java = JavaClass()
    java.sayHello("Java")
    println(java.javaString)
    //由于Java中可以定义null，所以在kotlin中要做可空性判断，避免发生空指针异常
    val javaString:String? = java.javaString
    javaString?.uppercase()
}

2)定义kotlin类

class KotlinClass {
    val kotlinString="Kotlin"

    fun sayHello(name: String) {
        println("Hello $name")
    }
}

Java中调用Kotlin中的属性和方法

 public static void main(String[] args) {
        KotlinClass kotlin = new KotlinClass();
        kotlin.sayHello("Kotlin");
       String kotlinString =  kotlin.getKotlinString();
        System.out.println(kotlinString);
    }

Java中访问Kotlin中的属性，必须通过getter setter方法。如果想直接访问，得需要在kotlin中定义的属性加上。

class KotlinClass {
    @JvmField
    val kotlinString="Kotlin"
}

 public static void main(String[] args) {
     KotlinClass kotlin = new KotlinClass();
     String kotlinString =  kotlin.kotlinString;
     System.out.println(kotlinString);
}

2.当定义的kotlin函数参数有默认值时，@JvmOverloads 可以使kotlin编译器生产重载方法。

class KotlinClass {
    @JvmOverloads
    fun sayHello(name: String = "kotlin") {
        println("Hello $name")
    }
}

 public static void main(String[] args) {
     KotlinClass kotlin = new KotlinClass();
     kotlin.sayHello();
     kotlin.sayHello("Kotlin");
 }

看一下kotlin通过编译器生成的重载方法

public final class KotlinClass {
   @JvmOverloads
   public final void sayHello(@NotNull String name) {
      Intrinsics.checkNotNullParameter(name, "name");
      String var2 = "Hello " + name;
      System.out.println(var2);
   }

   // $FF: synthetic method
   public static void sayHello$default(KotlinClass var0, String var1, int var2, Object var3) {
      if ((var2 & 1) != 0) {
         var1 = "kotlin";
      }

      var0.sayHello(var1);
   }

   @JvmOverloads
   public final void sayHello() {
      sayHello$default(this, (String)null, 1, (Object)null);
   }
}

3.Java访问Kotlin中的伴生对象属性和方法。

class KotlinClass {

    companion object {
        val HELLO_WORLD = "hello world"
        fun sayHello() = println(HELLO_WORLD)
    }
}

 public static void main(String[] args) {
        KotlinClass.Companion.getHELLO_WORLD();
        KotlinClass.Companion.sayHello();
    }

@JvmField 可以以静态的方法来访问伴生对象中定义的属性。

@JvmStatic定义在函数上，可以直接调用伴生对象中的函数。

class KotlinClass {

    companion object {
        @JvmField
        val HELLO_WORLD = "hello world"
        @JvmStatic
        fun sayHello() = println(HELLO_WORLD)
    }
}

   public static void main(String[] args) {
//     KotlinClass.Companion.getHELLO_WORLD();
//     KotlinClass.Companion.sayHello();
       String hello =  KotlinClass.HELLO_WORLD;
       KotlinClass.sayHello();
    }

4.异常处理。

 1）Kotlin捕获Java中的异常

     java中抛出的异常，在java中调用时，编译器会自动提示要捕获异常。

    但是在Kotlin中调用时，不捕获异常也会编译通过

public class JavaClass {
    public void testException() throws IOException {
        System.out.println("exception");
    }

    public static void main(String[] args) {
        try {
            new JavaClass().testException();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Kotlin中调用java代码
fun main() {
    val java = JavaClass()
    java.testException();
}

2）在Kotlin中抛出的异常，必须加上Throws注解，在java中才会自动提示捕获异常。

      @Throws(IOException::class) 

class KotlinClass {
    @Throws(IOException::class)
    fun testException(){
        throw IOException()
    }
}

public class JavaClass {
    public void testException() throws IOException {
        System.out.println("exception");
    }

    public static void main(String[] args) {
        KotlinClass kotlin = new KotlinClass();
        try {
            kotlin.testException();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5.Java中调用Kotlin中定义的匿名函数

 在kotlin中定义两个匿名函数，一个是一个参数，一个是两个参数。

class KotlinClass {
   val sayHello = { name:String ->
        println("Hello $name")
   }
    val sayHello2 = { name:String,name2:String ->
        println("Hello $name and $name2")
    }
}

在java中调用Kotlin中的匿名函数。通过Function1 invoke，可以调用一个参数的匿名函数，

通过Function2.invoke可以调用两个参数的匿名函数，一次类推可以从Function0--Function22.

Function0代表无参的匿名函数，Function22最多可以接收22个参数。

 public static void main(String[] args) {
        KotlinClass kotlin = new KotlinClass();

        Function1 function1 = kotlin.getSayHello();
        function1.invoke("HanMei");

        Function2 function2 = kotlin.getSayHello2();
        function2.invoke("HanMei","LiLei");
    }