Kotlin 与 Java 互操作性教程

2025-3-13

Kotlin 与 Java 互操作性教程

Kotlin 最引人注目的特性之一是其与 Java 的无缝互操作性。这意味着你可以在 Kotlin 代码中直接使用现有的 Java 库、框架和工具，反之亦然。这种互操作性使得将 Kotlin 逐步引入现有 Java 项目变得非常容易，而无需进行大规模的代码重写。

1. 互操作性基础

Kotlin 和 Java 都是运行在 Java 虚拟机 (JVM) 上的语言。Kotlin 代码会被编译成与 Java 字节码兼容的字节码。这使得 Kotlin 和 Java 代码可以互相调用，就像它们是用同一种语言编写的一样。

主要互操作性场景：

Kotlin 调用 Java： 这是最常见的场景。Kotlin 代码可以直接创建 Java 类的实例、调用 Java 方法、访问 Java 字段，以及实现 Java 接口和继承 Java 类。
Java 调用 Kotlin： Java 代码也可以调用 Kotlin 代码，但需要注意一些 Kotlin 特有的特性，例如属性、顶层函数、空安全等，后续会详细讲解。

2. Kotlin 调用 Java

Kotlin 在设计时就充分考虑了与 Java 的互操作性。在大多数情况下，你可以像在 Java 中一样使用 Java 代码。

2.1. 使用 Java 类和方法

```kotlin
// Kotlin 代码
import java.util.ArrayList

fun main() {
// 创建 Java ArrayList 的实例
val list: ArrayList = ArrayList()

// 调用 Java 方法
list.add("Hello")
list.add("World")

println(list.size) // 输出: 2
println(list.get(0)) // 输出: Hello

// 使用 Java 的静态方法
 val max =  java.lang.Math.max(10,20)
  println(max) //输出 20

}
```

2.2. 访问 Java 字段

```kotlin
// Java 代码 (Person.java)
public class Person {
public String name;
public int age;

public Person(String name, int age)
{
    this.name = name;
    this.age = age;
}

}
```

```kotlin
// Kotlin 代码
fun main() {
val person = Person("Alice", 30)

// 访问 Java 字段
println(person.name) // 输出: Alice
person.age = 31
println(person.age) // 输出: 31

}
```

2.3. 处理 Java 的 getter 和 setter

对于遵循 Java Bean 规范的 getter 和 setter 方法，Kotlin 提供了更简洁的属性访问语法。

```java
// Java 代码 (Book.java)
public class Book {
private String title;
private String author;

public String getTitle() {
    return title;
}

public void setTitle(String title) {
    this.title = title;
}

public String getAuthor() {
    return author;
}

public void setAuthor(String author) {
    this.author = author;
}

}
```

```kotlin
// Kotlin 代码
fun main() {
val book = Book()

// 使用属性访问语法，实际上调用了 setTitle 和 setAuthor 方法
book.title = "Kotlin in Action"
book.author = "Dmitry Jemerov"

// 使用属性访问语法，实际上调用了 getTitle 和 getAuthor 方法
println(book.title) // 输出: Kotlin in Action
println(book.author) // 输出: Dmitry Jemerov

}
```

2.4. 处理 Java 集合

Kotlin 可以直接使用 Java 的集合类 (如 ArrayList, HashMap, HashSet 等)。 Kotlin 的集合接口 (List, Map, Set) 与 Java 的集合接口是兼容的。

```kotlin
// Kotlin 代码
import java.util.*

fun main() {
val javaList: List = ArrayList() // 使用 Java 的 ArrayList
javaList.add("Java")
javaList.add("Kotlin")

val kotlinList: List<String> = javaList // Java 集合可以直接赋值给 Kotlin 集合

println(kotlinList) // 输出: [Java, Kotlin]

}
```

2.5. 处理 Java 异常

Kotlin 没有 checked exception。这意味着你不需要显式地捕获或声明 Java 方法可能抛出的 checked exception。但是, 你仍然可以使用 try-catch 块来处理异常。

```java
// Java 代码 (FileReaderExample.java)
import java.io.FileReader;
import java.io.IOException;

public class FileReaderExample {
public void readFile(String filename) throws IOException {
FileReader reader = new FileReader(filename);
// ... 读取文件内容 ...
reader.close();
}
}
```

```kotlin
// Kotlin 代码
fun main() {
val fileReader = FileReaderExample()

try {
    fileReader.readFile("somefile.txt") // 不需要声明 throws IOException
} catch (e: IOException) {
    // 处理异常
    println("Error reading file: ${e.message}")
}

}
```

3. Java 调用 Kotlin

Java 代码也可以调用 Kotlin 代码，但需要注意一些 Kotlin 特有的特性。

3.1. 访问 Kotlin 属性

Kotlin 属性会被编译成 Java 的 getter 和 setter 方法。对于 val 属性（只读），只有 getter 方法；对于 var 属性（可读写），有 getter 和 setter 方法。

kotlin // Kotlin 代码 (User.kt) class User { val name: String = "Alice" // 只读属性 var age: Int = 30 // 可读写属性 }

```java
// Java 代码
public class Main {
public static void main(String[] args) {
User user = new User();

    // 调用 getter 方法
    System.out.println(user.getName()); // 输出: Alice

    // 调用 getter 和 setter 方法
    System.out.println(user.getAge()); // 输出: 30
    user.setAge(31);
    System.out.println(user.getAge()); // 输出: 31
}

}
```

3.2. 访问 Kotlin 顶层函数和属性

Kotlin 的顶层函数和属性会被编译成一个名为 文件名+Kt 的 Java 类的静态方法和静态字段。

```kotlin
// Kotlin 代码 (Utils.kt)
package com.example

val PI = 3.14159

fun add(a: Int, b: Int): Int {
return a + b
}
```

```java
// Java 代码
import com.example.UtilsKt;

public class Main {
public static void main(String[] args) {
// 访问顶层属性
System.out.println(UtilsKt.getPI()); // 输出: 3.14159

    // 调用顶层函数
    int sum = UtilsKt.add(5, 3);
    System.out.println(sum); // 输出: 8
}

}
可以使用`@file:JvmName("UtilClass")`注解，来自定义生成的Java类的名字。kotlin
// Kotlin 代码 (Utils.kt)
@file:JvmName("UtilClass")
package com.example

val PI = 3.14159

fun add(a: Int, b: Int): Int {
return a + b
}
```

```java
// Java 代码
import com.example.UtilClass;

public class Main {
public static void main(String[] args) {
// 访问顶层属性
System.out.println(UtilClass.getPI()); // 输出: 3.14159

    // 调用顶层函数
    int sum = UtilClass.add(5, 3);
    System.out.println(sum); // 输出: 8
}

}
```

3.3. 处理 Kotlin 对象声明 (Object Declaration)

Kotlin 的对象声明（单例模式）会被编译成一个包含 INSTANCE 字段的 Java 类。

kotlin // Kotlin 代码 (Logger.kt) object Logger { fun log(message: String) { println("[LOG] $message") } }

```java
// Java 代码
import Logger;

public class Main {
public static void main(String[] args) {
// 通过 INSTANCE 字段访问单例对象
Logger.INSTANCE.log("Hello from Java"); // 输出: [LOG] Hello from Java
}
}
```

3.4. 处理 Kotlin 扩展函数

Kotlin 扩展函数会被编译成一个静态方法，该方法的第一个参数是接收者对象。

kotlin // Kotlin 代码 (StringExtensions.kt) fun String.addExclamation(): String { return this + "!" }

```java
// Java 代码
import StringExtensionsKt;

public class Main {
public static void main(String[] args) {
String str = "Hello";
// 调用扩展函数，将接收者对象作为第一个参数
String result = StringExtensionsKt.addExclamation(str);
System.out.println(result); // 输出: Hello!
}
}
`` 同样可以使用@file:JvmName("StringUtil")`注解来自定义生成的类的名字。

3.5. 处理 Kotlin 空安全

Kotlin 的空安全特性在编译时会进行检查。在 Java 中调用 Kotlin 代码时，需要注意 Kotlin 代码中可能为 null 的类型。

kotlin // Kotlin 代码 (StringUtils.kt) fun toUpperCase(str: String?): String? { return str?.toUpperCase() }

```java
// Java 代码

import org.jetbrains.annotations.Nullable;
import StringUtilsKt;

public class Main {
public static void main(String[] args) {
// 调用可能返回 null 的 Kotlin 函数
@Nullable String result = StringUtilsKt.toUpperCase("hello");
if (result != null) {
System.out.println(result); // 输出: HELLO
}

    // 传递 null 给 Kotlin 函数
    String nullResult = StringUtilsKt.toUpperCase(null);
    System.out.println(nullResult); // 输出: null
}

}
`` 在Kotlin代码中，可以使用@Nullable和@NotNull`注解，来显式指定参数或者返回值的可空性。

4. 高级互操作性

4.1. 使用 `@JvmName` 注解

@JvmName 注解可以用于更改 Kotlin 代码生成的 Java 字节码中的名称。这在处理名称冲突或希望为 Java 调用方提供更友好的 API 时非常有用。

kotlin // Kotlin 代码 @JvmName("calculateSum") fun sum(a: Int, b: Int): Int { return a + b }

java // Java 代码 public class Main { public static void main(String[] args) { // 使用 @JvmName 指定的名称调用 Kotlin 函数 int result = calculateSum(5, 3); System.out.println(result); // 输出: 8 } }

4.2. 使用 `@JvmStatic` 注解

@JvmStatic 注解可以将伴生对象 (companion object) 中的方法或属性暴露为 Java 的静态方法或静态字段。

kotlin // Kotlin 代码 (MathUtils.kt) class MathUtils { companion object { @JvmStatic fun square(x: Int): Int { return x * x } } }

java // Java 代码 public class Main { public static void main(String[] args) { // 作为静态方法调用 int result = MathUtils.square(5); System.out.println(result); // 输出: 25 } }

4.3. 使用 `@JvmOverloads` 注解

@JvmOverloads 注解可以为具有默认参数值的 Kotlin 函数生成多个重载的 Java 方法。

kotlin // Kotlin 代码 class View { @JvmOverloads fun setVisibility(visible: Boolean, animate: Boolean = false) { // ... } }

java // Java 代码 public class Main { public static void main(String[] args) { View view = new View(); // 可以只传递一个参数，也可以传递两个参数 view.setVisibility(true); view.setVisibility(true, true); } }
不加@JvmOverloads注解，Java代码只能使用两个参数的函数。

4.4. 使用 `@JvmField` 注解

@JvmField 注解可以将 Kotlin 属性暴露为 Java 的 public 字段，而不是生成 getter 和 setter 方法。这可以提高性能，但会失去属性访问控制的好处。

kotlin // Kotlin 代码 class Point { @JvmField val x: Int = 0 @JvmField val y: Int = 0 }

```java
// Java 代码
public class Main {
public static void main(String[] args) {
Point point = new Point();

    // 直接访问字段
    System.out.println(point.x); // 输出: 0
    System.out.println(point.y); // 输出: 0
}

}
```

4.5 使用`@Throws`注解

该注解指定 Kotlin 函数可以抛出的已检查异常。

kotlin //Kotlin 代码 @Throws(IOException::class) fun readFile(name: String) { // ... }

java // Java 代码 import java.io.IOException; public class Main { public static void main(String[] args) { try{ readFile("someFIle.txt"); }catch(IOException e) { //异常处理 } } }