Java互操作
一、Kotlin中调用Java
Getter和Setter
public class Person {
private String name;
private String gender;
private int wage = 1000;
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getGender() { return gender; }
public void setGender(String gender) { this.gender = gender; }
public void setWage(int wage) { this.wage = wage; }
}fun main() {
val person = Person()
person.name = "yao"
person.gender = "male"
println(person.wage)
// 无法访问，因为wage只有setter，它在Kotlin中不会作为属性可见。
// Kotlin目前不支持只写属性。
}返回void的方法
如果一个Java方法返回void，从Kotlin调用时返回Unit。
val person = Person()
person.gender = "male"
println(person.setWage(100)) // kotlin.Unit空安全
Java中声明的类型在Kotlin中称为平台类型。调用平台类型变量的方法时，Kotlin不会在编译时报告可空性错误，但运行时调用可能会失败。
val person = Person()
person.gender = "male"
println(person.name.substring(1)) // Exception平台类型
— T!表示T或者T?。
— (Mutable)Collection<T>!表示可以可变或不可变、可空或不可空的T的Java集合。
— Array<(out) T>!表示可空或者不可空的T（或T的子类型）的Java数组。
已映射类型
原生类型：
Java类型 | Kotlin类型 |
byte | kotlin.Byte |
short | kotlin.Short |
int | kotlin.Int |
long | kotlin.Long |
char | kotlin.Char |
float | kotlin.Float |
double | kotlin.Double |
Boolean | Kotlin.Boolean |
非原生类型：
Java类型 | Kotlin类型 |
java.lang.Object | kotlin.Any! |
java.lang.Cloneable | kotlin.Cloneable! |
java.lang.Comparable | kotlin.Comparable! |
java.lang.Enum | kotlin.Enum! |
java.lang.Annotation | kotlin.Annotation! |
java.lang.CharSequence | kotlin.CharSequence! |
java.lang.String | kotlin.String! |
java.lang.Number | kotlin.Number! |
java.lang.Throwable | kotlin.Throwable! |
装箱原始类型：
Java类型 | Kotlin类型 |
java.lang.Byte | kotlin.Byte? |
java.lang.Short | kotlin.Short? |
java.lang.Integer | kotlin.Int? |
java.lang.Long | kotlin.Long? |
java.lang.Character | kotlin.Char? |
java.lang.Float | kotlin.Float? |
java.lang.Double | kotlin.Double? |
java.lang.Boolean | Kotlin.Boolean? |
集合类型：
Java类型 | Kotlin只读类型 | Kotlin可变类型 | 加载的平台类型 |
Iterator | Iterator | MutableIterator | (Mutable)Iterator! |
Iterable | Iterable | MutableIterable | (Mutable)Iterable! |
Collection | Collection | MutableCollection | (Mutable)Collection! |
Set | Set | MutableSet | (Mutable)Set! |
List | List | MutableList | (Mutable)List! |
ListIterator | ListIterator | MutableListIterator | (Mutable)ListIterator! |
Map<K, V> | Map<K, V> | MutableMap<K, V> | (Mutable)Map<K, V>! |
Map.Entry<K, V> | Map.Entry<K, V> | MutableMap.Entry<K, V> | (Mutable)Map.(Mutable)Entry<K, V>! |
数组类型
Java类型 | Kotlin类型 |
int[] | kotlin.IntArray! |
String[] | kotlin.Arrat<(out) String>! |
Kotlin中的Java泛型
Foo<? extends Bar>转换成Foo<out Bar!>!
Foo<? super Bar>转换成Foo<in Bar!>!
List转换成List<*>!，即List<out Any?>!
Kotlin在运行时不保留泛型， Kotlin只允许is检测星投影的泛型类型：
if (a is List<Int>) // 错误：无法检测它是否真的是一个 Int 列表
if (a is List<*>) // OK：不保证列表的内容Java可变参数
public class JavaArrayExample {
public void removeIndicesVarArg(int... indices) {
// 在此编码……
}
}使用展开运算符*来传递IntArray，无法传递null。
val javaObj = JavaArrayExample()
val array = intArrayOf(0, 1, 2, 3)
javaObj.removeIndicesVarArg(*array)受检异常
在Kotlin中，所有异常是非受检的。
fun render(list: List<*>, to: Appendable) {
for (item in list) {
to.append(item.toString()) // Java 会要求我们在这里捕获 IOException
}
}对象方法
Java中的类型 java.lang.Object 的所有引用都成了Kotlin中的 Any。Any只声明了toString()、hashCode()、equals()作为其成员。
— wait() / notify()：需要将引用转换为java.lang.Object。
(foo as java.lang.Object).wait()— getClass()
val fooClass = foo::class.java
val fooClass = foo.javaClass— clone()：需要继承kotlin.Cloneable
class Example : Cloneable {
override fun clone(): Any { }
}— finalize()
class C {
protected fun finalize() {
// 终止化逻辑
}
}根据 Java 的规则，finalize() 不能是 private 的。
静态成员
要访问已映射到 Kotlin 类型的 Java 类型的静态成员，需要使用 Java 类型的完整限定名：java.lang.Integer.bitCount(foo)。
SAM转换
SAM = single abstract method
val runnable = Runnable { println("This runs in a runnable") }val executor = ThreadPoolExecutor()
// Java 签名：void execute(Runnable command)
executor.execute { println("This runs in a thread pool") }标识符转义
一些 Kotlin 关键字在 Java 中是有效标识符：in、object、is等等。 如果一个 Java 库使用了 Kotlin 关键字作为方法，可以通过反引号（`）字符转义它来调用该方法：
foo.`is`(bar)JNI
要声明一个在本地（C 或 C++）代码中实现的函数，需要使用 external 修饰符来标记它：
external fun foo(x: Int): Double二、Java中调用Kotlin
属性
var name: String编译成以下Java声明：
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}如果属性名称以is开头，例如isOpen，其getter为isOpen()，setter为setOpen()。
包级函数
在org.example包内app.kt文件中声明的所有的函数和属性，包括扩展函数， 都编译成一个名为org.example.AppKt的Java类的静态方法。
// app.kt
package org.example
class Util
fun getTime() { /*……*/ }// Java
new org.example.Util();
org.example.AppKt.getTime();可以使用@JvmName注解修改生成的Java类的类名。
@file:JvmName("DemoUtils")
package org.example
class Util
fun getTime() { /*……*/ }// Java
new org.example.Util();
org.example.DemoUtils.getTime();如果多个文件中生成了相同的 Java 类名（包名相同并且类名相同或者有相同的@JvmName注解），编译器能够生成一个单一的 Java 外观类，它具有指定的名称且包含来自所有文件中具有该名称的所有声明。需要所有相关文件中使用@JvmMultifileClass注解。
// oldutils.kt
@file:JvmName("Utils")
@file:JvmMultifileClass
package org.example
fun getTime() { /*……*/ }// newutils.kt
@file:JvmName("Utils")
@file:JvmMultifileClass
package org.example
fun getDate() { /*……*/ }// Java
org.example.Utils.getTime();
org.example.Utils.getDate();实例字段
如果一个属性有幕后字段、非私有、没有open / override或 const修饰符并且不是被委托的属性，可以用@JvmField注解该属性。
class User(id: String) {
@JvmField val ID = id
}// Java
class JavaClient {
public String getID(User user) {
return user.ID;
}
}静态字段
在具名对象或伴生对象中声明的 Kotlin 属性会在该具名对象或包含伴生对象的类中具有静态幕后字段。
通常这些字段是私有的，但是可以通过以下方式之一暴露出来。
@JvmField注解；
lateinit 修饰符；
const 修饰符。
使用@JvmField标注这样的属性使其成为与属性本身具有相同可见性的静态字段。
class Key(val value: Int) {
companion object {
@JvmField
val COMPARATOR: Comparator<Key> = compareBy<Key> { it.value }
}
}// Java
Key.COMPARATOR.compare(key1, key2);
// Key 类中的 public static final 字段在具名对象或者伴生对象中的一个延迟初始化的属性具有与属性 setter 相同可见性的静态幕后字段。
object Singleton {
lateinit var provider: Provider
}// Java
Singleton.provider = new Provider();
// 在 Singleton 类中的 public static 非-final 字段（在类中以及在顶层）以const声明的属性在 Java 中会成为静态字段：
// example.kt
object Obj {
const val CONST = 1
}
class C {
companion object {
const val VERSION = 9
}
}
const val MAX = 239// java
int const = Obj.CONST;
int max = ExampleKt.MAX;
int version = C.VERSION;静态方法
为具名对象或伴生对象中定义的函数生成静态方法，可以将这些函数标注为@JvmStatic。
伴生对象：
class C {
companion object {
@JvmStatic fun callStatic() {}
fun callNonStatic() {}
}
}// java
C.callStatic(); // 没问题
C.callNonStatic(); // 错误：不是一个静态方法
C.Companion.callStatic(); // 保留实例方法
C.Companion.callNonStatic(); // 唯一的工作方式具名对象：
object Obj {
@JvmStatic fun callStatic() {}
fun callNonStatic() {}
}// java
Obj.callStatic(); // 没问题
Obj.callNonStatic(); // 错误
Obj.INSTANCE.callNonStatic(); // 没问题，通过单例实例调用
Obj.INSTANCE.callStatic(); // 也没问题自 Kotlin 1.3 起，@JvmStatic也适用于在接口的伴生对象中定义的函数。 这类函数会编译为接口中的静态方法。
interface ChatBot {
companion object {
@JvmStatic fun greet(username: String) {
println("Hello, $username")
}
}
}接口中的默认方法
自JDK1.8起，Java重的借口可以包含默认方法，如需将一个成员声明为默认，需要使用@JvmDefault注解。
interface Robot {
@JvmDefault fun move() { println("~walking~") }
fun speak(): Unit
}//java
public class C3PO implements Robot {
// 来自 Robot 的 move() 实现隐式可用
@Override
public void speak() {
System.out.println("I beg your pardon, sir");
}
}接口的实现者可以覆盖默认方法。
为了让@JvmDefault生效，编译该接口必须带有-Xjvm-default参数。 根据添加注解的情况，指定下列值之一：
— -Xjvm-default=enabled只添加带有@JvmDefault 注解的新方法时使用。
— -Xjvm-default=compatibility将@JvmDefault添加到以往 API 中就有的方法时使用。
如果将带有 @JvmDefault 的方法的接口用作委托， 即使实际的委托类型提供了自己的实现，也会调用默认方法的实现。
interface Producer {
@JvmDefault fun produce() {
println("interface method")
}
}
class ProducerImpl: Producer {
override fun produce() {
println("class method")
}
}
class DelegatedProducer(val p: Producer): Producer by p {
}
fun main() {
val prod = ProducerImpl()
DelegatedProducer(prod).produce() // interface method
}可见性
Kotlin | Java |
private | private |
protected | protected |
internal | public |
public | public |
KClass
调用有KClass类型参数的 Kotlin 方法：
kotlin.jvm.JvmClassMappingKt.getKotlinClass(MainView.class)签名冲突
fun List<String>.filterValid(): List<String>
fun List<Int>.filterValid(): List<Int>这两个函数不能同时定义。如果我们真的希望它们在 Kotlin 中用相同名称，我们需要用@JvmName 去标注其中的一个（或两个），并指定不同的名称作为参数。
fun List<String>.filterValid(): List<String>
@JvmName("filterValidInt")
fun List<Int>.filterValid(): List<Int>在Kotlin中它们可以用相同的名称 filterValid 来访问，而在Java中，它们分别是filterValid和filterValidInt。
同样的技巧也适用于属性 x 和函数 getX() 共存。
val x: Int
@JvmName("getX_prop")
get() = 15
fun getX() = 10如需在没有显式实现 getter 与 setter 的情况下更改属性生成的访问器方法的名称，可以使用@get:JvmName与@set:JvmName：
@get:JvmName("x")
@set:JvmName("changeX")
var x: Int = 23生成重载
如果写一个有默认参数值的Kotlin函数，在Java中只会有一个所有参数都存在的完整参数签名的方法可见，如果希望向Java调用者暴露多个重载，可以使用@JvmOverloads注解。
class Circle @JvmOverloads constructor(centerX: Int, centerY: Int, radius: Double = 1.0) {
@JvmOverloads fun draw(label: String, lineWidth: Int = 1, color: String = "red") { /*……*/ }
}// 构造函数：
Circle(int centerX, int centerY, double radius)
Circle(int centerX, int centerY)
// 方法
void draw(String label, int lineWidth, String color) { }
void draw(String label, int lineWidth) { }
void draw(String label) { }受检异常
通常Kotlin函数的Java签名不会声明抛出异常。
package demo
fun writeToFile() {
/*……*/
throw IOException()
}// Java
try {
demo.Example.writeToFile();
}
catch (IOException e) { // 错误：writeToFile() 未在 throws 列表中声明 IOException
// ……
}因为writeToFile()没有声明IOException，Java 编译器得到一个报错消息。 为了解决这个问题，要在Kotlin中使用 @Throws 注解。
@Throws(IOException::class)
fun writeToFile() {
/*……*/
throw IOException()
}型变的泛型
class Box<out T>(val value: T)
interface Base
class Derived : Base
fun boxDerived(value: Derived): Box<Derived> = Box(value)
fun unboxBase(box: Box<Base>): Base = box.value// java
// 作为返回类型——没有通配符
Box<Derived> boxDerived(Derived value) { }
// 作为参数——有通配符
Base unboxBase(Box<? extends Base> box) { }在默认不生成通配符的地方需要通配符，可以使用 @JvmWildcard 注解：
fun boxDerived(value: Derived): Box<@JvmWildcard Derived> = Box(value)// java
Box<? extends Derived> boxDerived(Derived value) { }如果不需要默认的通配符转换，可以使用@JvmSuppressWildcards注解：
fun unboxBase(box: Box<@JvmSuppressWildcards Base>): Base = box.value// java
Base unboxBase(Box<Base> box) { }