X
admin

Kotlin与Java互操作(学习笔记七)

一. Kotlin调用Java

1.1 Kotlin使用Java的集合类

 val kotlinList = listOf(1, 2, 3, 4)


    //Java原生的ArrayList
    val javaList = ArrayList<Int>()


    for (item in kotlinList) {
        javaList.add(item)
    }

操作Java原生的集合类跟Kotlin中使用类没有什么区别。

1.2 调用Java类的getter和setter

假如我们有这样一个Person类。

package com.dengyin2000.java;
public class Person {
    private String name;
    private Long id;
    private boolean isFemale;


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }


    public Long getId() {
        return id;
    }


    public void setId(Long id) {
        this.id = id;
    }


    public boolean isFemale() {
        return isFemale;
    }


    public void setFemale(boolean female) {
        isFemale = female;
    }
}

那么在Kotlin中要怎样使用呢？

val person = Person()   
    person.id = 1
    person.name = "Denny"
    person.isFemale = false


    println("Person(id=${person.id}, name=${person.name}, isFemale=${person.isFemale})")

println函数中的person类调用的是Person类的getter，上面属性设置实际上调用的是Person类的setter方法。

1.3 空安全

  Java声明的类型在Kotlin中会被特别对待并称为平台类型（platform types），对于这种类型的空检查会放宽，这样做就使得跟Java的调用方式一致，但是Java中的任何引用都可能为null，这样我们使用Kotlin调用来自Java的对象的时候就有可能会出现空安全的问题。例如：

   val person = Person()    
    person.id = 1
    person.isFemale = false
    println(person.name.substring(1))

person.name运行时为null，当然调用的时候会person.name.substring(1)时会发生异常。

异常

当然为了避免null的问题，我们可以使用Koltin的安全调用：

println(person.name?.substring(1))  //打印null

1.4 平台类型

平台类型不能在程序中显式表述，因此在语言中没有相应语法。然而，编译器和 IDE 有时需要（在错误信息中、参数信息中等）显示他们，所以我们用一个助记符来表示他们：

  • T! : 表示 T 或者 T?

  • (Mutable) Collection<T>! : 表示 “可以可变或不可变、可空或不可空的 T 的 Java 集合”

  • Array<(out) T>! : 表示“可空或者不可空的 T（或 T 的子类型）的 Java 数组”

1.5 Kotlin与Java中的类型映射

Kotlin 特殊处理一部分 Java 类型。这样的类型不是“按原样”从 Java 加载，而是 映射 到相应的 Kotlin 类型。映射只发生在编译期间，运行时表示保持不变。怎么理解这句话呢？就是说在Kotlin中加载这些Java的类型时，编译器会转成对应的Kotlin类型，这样就能用到Koltin中对Java的增强功能（扩展函数等）。

1.5.1 Java的原生类型映射到对应的Kotlin类型

Java的原生类型映射到对应的Kotlin类型

1.5.2 Java中的一些内置类型也会做相应的映射

Java中的一些内置类型也会做相应的映射

1.5.3 Java的基本类型的包装类对应到可空额Kotlin类型

Java的基本类型的包装类对应到可空额Kotlin类型

1.5.4 类型参数的Java类型映射到Kotlin中的平台类型

例如：List<java.lang.Integer> 在Kotlin会变成List<Int!>
集合类型在 Kotlin 中可以是只读的或可变的，因此 Java 集合类型作如下映射：（下表中的所有 Kotlin 类型都在 kotlin.collections包中）:

类型参数的Java类型映射到Kotlin中的平台类型

1.5.5 Java的数组映射

Java的数组映射

1.6 Kotlin中使用Java泛型

Kotlin 的泛型与 Java 有点不同。当将 Java 类型导入 Kotlin 时，我们会执行一些转换：

Kotlin中使用Java泛型

和 Java 一样，Kotlin 在运行时不保留泛型，即对象不携带传递到他们构造器中的那些类型参数的实际类型。

1.7 Java可变参数

假如我们有一个这样的类，有一个可变参数的静态方法：

package com.dengyin2000.java;public class StringUtils {


    public static String connect(String... strings) {
        StringBuilder sb = new StringBuilder();
        for (String string : strings) {
            sb.append(string).append(",");
        }
        return sb.toString();
    }
}

因为Kotlin并没有可变类型，所以我们需要使用*来传递一个String数组来达到相应的目的：

val listOf = arrayOf("Denny", "Deng")   
 println(StringUtils.connect(*listOf))  //打印Denny,Deng

1.8 Unchecked Exception

在Kotlin中，所有的异常都是Unchecked Exception，也就是说编译器不会强迫你捕获任何的异常，但是在Java中你是需要捕获Checked Exception。如下：

Java Checked Exception

我们需要try catch保护起来。


但是在Kotlin中不需要try catch，只是路过抛出来你没有try catch的话，程序还是会挂。

1.9 java.lang.Object方法使用

当 Java 类型导入到 Kotlin 中时，类型 java.lang.Object 的所有引用都成了 Any。而因为 Any 不是平台指定的，它只声明了 toString()、hashCode() 和 equals() 作为其成员， 所以为了能用到 java.lang.Object 的其他成员，你需要如下手段：

1.9.1 wait() / notify()

需要把对象转成java.lang.Object来使用：

val p = Person() 
(p as java.lang.Object).wait()
1.9.2 getClass()

要取得对象的 Java 类，我们可以在类引用上使用 java 扩展属性，它是Kotlin的反射类kotlin.reflect.KClass的扩展属性。

val fooClass = foo::class.java

上面的代码使用了自 Kotlin 1.1 起支持的绑定类引用。我们也可以使用 javaClass 扩展属性。

val fooClass = foo.javaClass
1.9.3 clone()

要覆盖 clone()，需要继承 kotlin.Cloneable：

class Example : Cloneable {  
  override fun clone(): Any { …… }
}

1.10 Kotlin与Java 的反射

我们可以使用 instance::class.java、ClassName::class.java 或者 instance.javaClass 通过 java.lang.Class 来进入 Java 的反射类java.lang.Class， 之后我们就可以使用Java中的反射的功能特性了。

1.11 SAM转换

SAM = single abstract method，在Java中被称为SAM类型。例如：Runnable接口。在Kotlin中我们可以这样创建SAM接口实例：

val runnable = Runnable { println("SAM") }

1.12 Java使用了Kotlin的关键字

一些 Kotlin 关键字在 Java 中是有效标识符：in、 object、 is等等。
如果一个 Java 库使用了 Kotlin 关键字作为方法，我们可以通过反引号（`）字符转义它来调用该方法。例如我们有个Java类，其中有个is方法：

public class StringUtils {
    public static boolean is(String value, String value1) {
        return value.equals(value1);
    }
}

我们需要在Kotlin中需要这样调用：

println(StringUtils.`is`("a", "b"))  //打印false

二. Java调用Kotlin

      Kotlin最终还是会编译成class，所以要怎么调Kotlin其实就是要看Kotlin翻译成的class是怎样的。Kotlin可以通过一些annotation来调整Kotlin翻译成的class结果。

2.1 Java访问Kotlin属性

假如我们有下面一个Kotlin的类：

class Student{    
    var id: Long = -1L
    var name: String = "Denny"
    var isFemale: Boolean = false
}

我们通过Intellij IDEA的Tools->Kotlin->Show Kotlin Bytecode->Decompile可以看到生成的Java的代码如下：

public final class Student {   private long id = -1L;
   @NotNull
   private String name = "Denny";
   private boolean isFemale;


   public final long getId() {
      return this.id;
   }


   public final void setId(long var1) {
      this.id = var1;
   }


   @NotNull
   public final String getName() {
      return this.name;
   }


   public final void setName(@NotNull String var1) {
      Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
      this.name = var1;
   }


   public final boolean isFemale() {
      return this.isFemale;
   }


   public final void setFemale(boolean var1) {
      this.isFemale = var1;
   }
}

看到Java代码，你应该知道怎么调用了吧。

2.2 Java调用Kotlin包级函数

在package com.dengyin2000.kotlintest1包里面的StringUtil.kt文件中生命的所有函数、属性、都将编译成一个名为com.dengyin2000.kotlintest1.StringUtilKt的Java类的静态方法。假如我们有一个下面的Kotlin文件：

package com.dengyin2000.kotlintest1
fun sayHello() {
    println("Hello ${name}")
}
val name:String = "Denny"


fun String.firstChar() :Char{
    return this[0]
}


fun main(args: Array<String>) {
    println("Denny".firstChar())
}

通过上面的方式可以看到生成的Java代码如下：

package com.dengyin2000.kotlintest1;
import kotlin.Metadata;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;


public final class StringUtilKt {
   @NotNull
   private static final String name = "Denny";


   public static final void sayHello() {
      String var0 = "Hello " + name;
      System.out.println(var0);
   }


   @NotNull
   public static final String getName() {
      return name;
   }


   public static final char firstChar(@NotNull String $receiver) {
      Intrinsics.checkParameterIsNotNull($receiver, "$receiver");
      return $receiver.charAt(0);
   }


   public static final void main(@NotNull String[] args) {
      Intrinsics.checkParameterIsNotNull(args, "args");
      char var1 = firstChar("Denny");
      System.out.println(var1);
   }
}

可以看到String的扩展函数第一个参数变成了接受者。如果我们想要修改生成的Java对象的名称，我们可以使用@file:JvmName注解，如下：

@file:JvmName("Strings")
package com.dengyin2000.kotlintest1
fun sayHello() {
    println("Hello ${name}")
}
val name:String = "Denny"
fun String.firstChar() :Char{
    return this[0]
}
fun main(args: Array<String>) {
    println("Denny".firstChar())
}

这样生成的类名变成了Strings。

2.3 实例字段

如果我们不希望某个属性生成getter setter方法，我们希望生成一个实例字段的话，我们可以使用@JvmField注解标注Kotlin的属性。如下：

class Student{    var id: Long = -1L
    var name: String = "Denny"
    var isFemale: Boolean = false
    
    @JvmField
    var grade: Int = 0
}

生成的Java如下：

public final class Student {  
   private long id = -1L;
   @NotNull
   private String name = "Denny";
   private boolean isFemale;
   @JvmField
   public int grade;


   public final long getId() {
      return this.id;
   }


   public final void setId(long var1) {
      this.id = var1;
   }


   @NotNull
   public final String getName() {
      return this.name;
   }


   public final void setName(@NotNull String var1) {
      Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
      this.name = var1;
   }


   public final boolean isFemale() {
      return this.isFemale;
   }


   public final void setFemale(boolean var1) {
      this.isFemale = var1;
   }
}

2.4 静态字段

在伴生对象和命名对象（object 类）的属性上使用@JvmField的区别如下：

class Student{   
    var id: Long = -1L
    var name: String = "Denny"
    var isFemale: Boolean = false
    @JvmField
    var grade: Int = 0
    companion object {
        var teachName = "Sally"


        @JvmField
        var schoolMaster = "Noah"
    }
}

生成的Java代码如下：

public final class Student {   private long id = -1L;
   @NotNull
   private String name = "Denny";
   private boolean isFemale;
   @JvmField
   public int grade;
   @NotNull
   private static String teachName = "Sally";
   @JvmField
   @NotNull
   public static String schoolMaster = "Noah";
   public static final Student.Companion Companion = new Student.Companion((DefaultConstructorMarker)null);


   public final long getId() {
      return this.id;
   }


   public final void setId(long var1) {
      this.id = var1;
   }


   @NotNull
   public final String getName() {
      return this.name;
   }


   public final void setName(@NotNull String var1) {
      Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
      this.name = var1;
   }


   public final boolean isFemale() {
      return this.isFemale;
   }


   public final void setFemale(boolean var1) {
      this.isFemale = var1;
   }
   public static final class Companion {
      @NotNull
      public final String getTeachName() {
         return Student.teachName;
      }


      public final void setTeachName(@NotNull String var1) {
         Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
         Student.teachName = var1;
      }


      private Companion() {
      }


      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}

调用方式如下：

        

String schoolMaster = Student.schoolMaster;
String teachName = Student.Companion.getTeachName();

2.5 静态方法

类似的只要将伴生对象或者命名对象的的方法用@JvmStatic注释，这样就能生成Java的静态方法。Kotlin代码如下：

class Student{   
 var id: Long = -1L
    var name: String = "Denny"
    var isFemale: Boolean = false
    @JvmField
    var grade: Int = 0


    companion object {
        var teachName = "Sally"


        @JvmField
        var schoolMaster = "Noah"


        @JvmStatic
        fun sayHello() {
            println("Hello world")
        }
    }
}

生成的Java代码如下：

public final class Student {   private long id = -1L;
   @NotNull
   private String name = "Denny";
   private boolean isFemale;
   @JvmField
   public int grade;
   @NotNull
   private static String teachName = "Sally";
   @JvmField
   @NotNull
   public static String schoolMaster = "Noah";
   public static final Student.Companion Companion = new Student.Companion((DefaultConstructorMarker)null);


   public final long getId() {
      return this.id;
   }


   public final void setId(long var1) {
      this.id = var1;
   }


   @NotNull
   public final String getName() {
      return this.name;
   }


   public final void setName(@NotNull String var1) {
      Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
      this.name = var1;
   }


   public final boolean isFemale() {
      return this.isFemale;
   }


   public final void setFemale(boolean var1) {
      this.isFemale = var1;
   }


   @JvmStatic
   public static final void sayHello() {
      Companion.sayHello();
   }


   public static final class Companion {
      @NotNull
      public final String getTeachName() {
         return Student.teachName;
      }


      public final void setTeachName(@NotNull String var1) {
         Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
         Student.teachName = var1;
      }


      @JvmStatic
      public final void sayHello() {
         String var1 = "Hello world";
         System.out.println(var1);
      }


      private Companion() {
      }


      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}

这样调用

Student.sayHello();

2.6 生成重载方法

    通常，如果你写一个有默认参数值的 Kotlin 函数，在 Java 中只会有一个所有参数都存在的完整参数签名的方法可见，如果希望向 Java 调用者暴露多个重载，可以使用 @JvmOverloads 注解。

该注解也适用于构造函数、静态方法等。它不能用于抽象方法，包括在接口中定义的方法。

Kotlin的类如下：

class Animal @JvmOverloads constructor(name: String, type: Int = 0){    
    fun talk(name: String, by: Int = 1) {


    }


    @JvmOverloads
    fun talkTo(name: String, by: Int = 1) {
        
    }
}

生成的Java代码如下：

public final class Animal {   public final void talk(@NotNull String name, int by) {
      Intrinsics.checkParameterIsNotNull(name, "name");
   }


   // $FF: synthetic method
   // $FF: bridge method
   public static void talk$default(Animal var0, String var1, int var2, int var3, Object var4) {
      if ((var3 & 2) != 0) {
         var2 = 1;
      }


      var0.talk(var1, var2);
   }


   @JvmOverloads
   public final void talkTo(@NotNull String name, int by) {
      Intrinsics.checkParameterIsNotNull(name, "name");
   }


   // $FF: synthetic method
   // $FF: bridge method
   @JvmOverloads
   public static void talkTo$default(Animal var0, String var1, int var2, int var3, Object var4) {
      if ((var3 & 2) != 0) {
         var2 = 1;
      }


      var0.talkTo(var1, var2);
   }


   @JvmOverloads
   public final void talkTo(@NotNull String name) {
      talkTo$default(this, name, 0, 2, (Object)null);
   }


   @JvmOverloads
   public Animal(@NotNull String name, int type) {
      Intrinsics.checkParameterIsNotNull(name, "name");
      super();
   }


   // $FF: synthetic method
   @JvmOverloads
   public Animal(String var1, int var2, int var3, DefaultConstructorMarker var4) {
      if ((var3 & 2) != 0) {
         var2 = 0;
      }


      this(var1, var2);
   }


   @JvmOverloads
   public Animal(@NotNull String name) {
      this(name, 0, 2, (DefaultConstructorMarker)null);
   }
}

生成了两个构造方法，talkTo也生成了两个方法，talk就只有一个；

重载构造方法

重载方法

2.7 可见性

Kotlin 的可见性与Java的可见性的映射关系如下表所示：

可见性

2.8 Kotlin中异常

在Kotlin中是不需要显示的try catch Checked Exception的，比如下面这个throwException方法：

class Animal @JvmOverloads constructor(name: String, type: Int = 0){
    fun talk(name: String, by: Int = 1) {


    }


    @JvmOverloads
    fun talkTo(name: String, by: Int = 1) {


    }


    fun throwException() {
        throw Exception("hahaha")
    }
}

在Java中调用不需要try catch。

no try catch


如果你想让Java调用时需要主动try catch的话，那你需要使用@Throws(Exception::class)注解。

注解


这时候Java调用方就需要try catch了。

关注我获取更多知识或者投稿


作者：dengyin2000
链接：https://www.jianshu.com/p/d8a115427242

本网站文章均为原创内容，并可随意转载，但请标明本文链接
如有任何疑问可在文章底部留言。为了防止恶意评论，本博客现已开启留言审核功能。但是博主会在后台第一时间看到您的留言，并会在第一时间对您的留言进行回复！欢迎交流！
本文链接: https://leetcode.jp/kotlin与java互操作(学习笔记七)/
Categories: Android
admin:
Leave a Comment
Related Post
  1. Android编程-深入探索Android卡顿优化
  2. Android编程-经过一顿骚操作，项目编译打包速度提升一倍！
  3. Android编程-（建议精读）灵魂之力—提升学习效率 99% 的私藏秘籍全公开