Kotlin調用Java代碼

Kotlin 在設計時就考慮了 Java 互操作性。可以從 Kotlin 中自然地調用現存的 Java 代碼，並且在 Java 代碼中也可以
很順利地調用 Kotlin 代碼。在本節中我們會介紹從 Kotlin 中調用 Java 代碼的一些細節。

幾乎所有 Java 代碼都可以使用而沒有任何問題

import java.util.*

fun demo(source: List<Int>) {
    val list = ArrayList<Int>()
    // 「for」-循環用於 Java 集合：
    for (item in source) {
        list.add(item)
    }
    // 操作符約定同樣有效：
    for (i in 0..source.size() - 1) {
        list[i] = source[i] // 調用 get 和 set
    }
}

Getter 和 Setter

遵循 Java 約定的 getter 和 setter 的方法(名稱以 get 開頭的無參數方法和
以 set 開頭的單參數方法)在 Kotlin 中表示爲屬性。例如：

import java.util.Calendar

fun calendarDemo() {
    val calendar = Calendar.getInstance()
    if (calendar.firstDayOfWeek == Calendar.SUNDAY) {  // 調用 getFirstDayOfWeek()
        calendar.firstDayOfWeek = Calendar.MONDAY       // 調用 setFirstDayOfWeek()
    }
}

請注意，如果 Java 類只有一個 setter，它在 Kotlin 中不會作爲屬性可見，因爲 Kotlin 目前不支持只寫(set-only)屬性。

返回 void 的方法

如果一個 Java 方法返回 void，那麼從 Kotlin 調用時中返回 Unit。
萬一有人使用其返回值，它將由 Kotlin 編譯器在調用處賦值，
因爲該值本身是預先知道的(是 Unit)。

將 Kotlin 中是關鍵字的 Java 標識符進行轉義

一些 Kotlin 關鍵字在 Java 中是有效標識符：in{: .keyword }、 object{: .keyword }、 is{: .keyword } 等等。
如果一個 Java 庫使用了 Kotlin 關鍵字作爲方法，你仍然可以通過反引號(`)字符轉義它
來調用該方法

foo.`is`(bar)

空安全和平臺類型

Java 中的任何引用都可能是 null{: .keyword }，這使得 Kotlin 對來自 Java 的對象要求嚴格空安全是不現實的。
Java 聲明的類型在 Kotlin 中會被特別對待並稱爲平臺類型。對這種類型的空檢查會放寬，
因此它們的安全保證與在 Java 中相同(更多請參見下文)。

考慮以下示例：

val list = ArrayList<String>() // 非空(構造函數結果)
list.add("Item")
val size = list.size() // 非空(原生 int)
val item = list[0] // 推斷爲平臺類型(普通 Java 對象)

當我們調用平臺類型變量的方法時，Kotlin 不會在編譯時報告可空性錯誤，
但在運行時調用可能會失敗，因爲空指針異常或者 Kotlin 生成的阻止空值傳播的斷言：

item.substring(1) // 允許，如果 item == null 可能會拋出異常

平臺類型是不可標示的，意味着不能在語言中明確地寫下它們。
當把一個平臺值賦值給一個 Kotlin 變量時，可以依賴類型推斷(該變量會具有推斷出的的平臺類型，
如上例中 item 所具有的類型)，或者我們可以選擇我們期望的類型(可空或非空類型均可)：

val nullable: String? = item // 允許，沒有問題
val notNull: String = item // 允許，運行時可能失敗

如果我們選擇非空類型，編譯器會在賦值時觸發一個斷言。這防止 Kotlin 的非空變量保存
空值。當我們把平臺值傳遞給期待非空值等的 Kotlin 函數時，也會觸發斷言。
總的來說，編譯器盡力阻止空值通過程序向遠傳播(儘管鑑於泛型的原因，有時這
不可能完全消除)。

平臺類型表示法

如上所述，平臺類型不能在程序中顯式表述，因此在語言中沒有相應語法。
然而，編譯器和 IDE 有時需要(在錯誤信息中、參數信息中等)顯示他們，所以我們用
一個助記符來表示他們：

T! 表示「T 或者 T?」，
(Mutable)Collection<T>! 表示「可以可變或不可變、可空或不可空的 T 的 Java 集合」，
Array<(out) T>! 表示「可空或者不可空的 T(或 T 的子類型)的 Java 數組」

可空性註解

具有可空性註解的Java類型並不表示爲平臺類型，而是表示爲實際可空或非空的
Kotlin 類型。編譯器支持多種可空性註解，包括：

JetBrains
(org.jetbrains.annotations 包中的 [@Nullable](https://github.com/Nullable "@Nullable") 和 [@NotNull](https://github.com/NotNull "@NotNull"))
Android(com.android.annotations 和 android.support.annotations)
JSR-305(javax.annotation)
FindBugs(edu.umd.cs.findbugs.annotations)
Eclipse(org.eclipse.jdt.annotation)
Lombok(lombok.NonNull)。

你可以在 Kotlin 編譯器源代碼中找到完整的列表。

已映射類型

Kotlin 特殊處理一部分 Java 類型。這樣的類型不是「按原樣」從 Java 加載，而是映射到相應的 Kotlin 類型。
映射只發生在編譯期間，運行時表示保持不變。
Java 的原生類型映射到相應的 Kotlin 類型(請記住平臺類型)：

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

{:.zebra}

一些非原生的內置類型也會作映射：

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.Deprecated

kotlin.Deprecated!

java.lang.CharSequence

kotlin.CharSequence!

java.lang.String

kotlin.String!

java.lang.Number

kotlin.Number!

java.lang.Throwable

kotlin.Throwable!

{:.zebra}

Java 的裝箱原始類型映射到可空的 Kotlin 類型：

Java type

Kotlin type

java.lang.Byte

kotlin.Byte?

java.lang.Short

kotlin.Short?

java.lang.Integer

kotlin.Int?

java.lang.Long

kotlin.Long?

java.lang.Char

kotlin.Char?

java.lang.Float

kotlin.Float?

java.lang.Double

kotlin.Double?

java.lang.Boolean

kotlin.Boolean?

{:.zebra}

請注意，用作類型參數的裝箱原始類型映射到平臺類型：
例如，List<java.lang.Integer> 在 Kotlin 中會成爲 List<Int!>。

集合類型在 Kotlin 中可以是隻讀的或可變的，因此 Java 集合類型作如下映射：
(下表中的所有 Kotlin 類型都駐留在 kotlin.collections包中):

Java 類型

Kotlin 只讀類型

Kotlin 可變類型

加載的平臺類型

Iterator<T>

MutableIterator<T>

(Mutable)Iterator<T>!

Iterable<T>

MutableIterable<T>

(Mutable)Iterable<T>!

Collection<T>

MutableCollection<T>

(Mutable)Collection<T>!

Set<T>

MutableSet<T>

(Mutable)Set<T>!

List<T>

MutableList<T>

(Mutable)List<T>!

ListIterator<T>

MutableListIterator<T>

(Mutable)ListIterator<T>!

Map<K, V>

MutableMap<K, V>

(Mutable)Map<K, V>!

Map.Entry<K, V>

MutableMap.MutableEntry<K,V>

(Mutable)Map.(Mutable)Entry<K, V>!

{:.zebra}

Java 的數組按下文所述映射：

Java 類型

Kotlin 類型

int[]

kotlin.IntArray!

String[]

kotlin.Array<(out) String>!

{:.zebra}

Kotlin 中的 Java 泛型

Kotlin 的泛型與 Java 有點不同(參見泛型)。當將 Java 類型導入 Kotlin 時，我們會執行一些轉換：

Java 的通配符轉換成類型投影
- Foo<? extends Bar> 轉換成 Foo<out Bar!>!
- Foo<? super Bar> 轉換成 Foo<in Bar!>!
Java的原始類型轉換成星投影
- List 轉換成 List<*>!，即 List<out Any?>!

和 Java 一樣，Kotlin 在運行時不保留泛型，即對象不攜帶傳遞到他們構造器中的那些類型參數的實際類型。
即 ArrayList<Integer>() 和 ArrayList<Character>() 是不能區分的。
這使得執行 is{: .keyword }-檢測不可能照顧到泛型。
Kotlin 只允許 is{: .keyword }-檢測星投影的泛型類型：

if (a is List<Int>) // 錯誤：無法檢查它是否真的是一個 Int 列表
// but
if (a is List<*>) // OK：不保證列表的內容

Java 數組

與 Java 不同，Kotlin 中的數組是不型變的。這意味着 Kotlin 不允許我們把一個 Array<String> 賦值給一個 Array<Any>，
從而避免了可能的運行時故障。Kotlin 也禁止我們把一個子類的數組當做超類的數組傳遞給 Kotlin 的方法，
但是對於 Java 方法，這是允許的(通過 Array<(out) String>! 這種形式的平臺類型)。

Java 平臺上，數組會使用原生數據類型以避免裝箱/拆箱操作的開銷。
由於 Kotlin 隱藏了這些實現細節，因此需要一個變通方法來與 Java 代碼進行交互。
對於每種原生類型的數組都有一個特化的類(IntArray、 DoubleArray、 CharArray 等等)來處理這種情況。
它們與 Array 類無關，並且會編譯成 Java 原生類型數組以獲得最佳性能。

假設有一個接受 int 數組索引的 Java 方法：

public class JavaArrayExample {

    public void removeIndices(int[] indices) {
        // 在此編碼……
    }
}

在 Kotlin 中你可以這樣傳遞一個原生類型的數組：

val javaObj = JavaArrayExample()
val array = intArrayOf(0, 1, 2, 3)
javaObj.removeIndices(array)  // 將 int[] 傳給方法

當編譯爲 JVM 字節代碼時，編譯器會優化對數組的訪問，這樣就不會引入任何開銷：

val array = arrayOf(1, 2, 3, 4)
array[x] = array[x] * 2 // 不會實際生成對 get() 和 set() 的調用
for (x in array) { // 不會創建迭代器
    print(x)
}

即使當我們使用索引定位時，也不會引入任何開銷

for (i in array.indices) {// 不會創建迭代器
    array[i] += 2
}

最後，in{: .keyword }-檢測也沒有額外開銷

if (i in array.indices) { // 同 (i >= 0 && i < array.size)
    print(array[i])
}

Java 可變參數

Java 類有時聲明一個具有可變數量參數(varargs)的方法來使用索引。

public class JavaArrayExample {

    public void removeIndices(int... indices) {
        // 在此編碼……
    }
}

在這種情況下，你需要使用展開運算符 * 來傳遞 IntArray：

val javaObj = JavaArray()
val array = intArrayOf(0, 1, 2, 3)
javaObj.removeIndicesVarArg(*array)

目前無法傳遞 null{: .keyword } 給一個聲明爲可變參數的方法。

操作符

由於 Java 無法標記用於運算符語法的方法，Kotlin 允許
具有正確名稱和簽名的任何 Java 方法作爲運算符重載和其他約定(invoke() 等)使用。
不允許使用中綴調用語法調用 Java 方法。

受檢異常

在 Kotlin 中，所有異常都是非受檢的，這意味着編譯器不會強迫你捕獲其中的任何一個。
因此，當你調用一個聲明受檢異常的 Java 方法時，Kotlin 不會強迫你做任何事情：

fun render(list: List<*>, to: Appendable) {
    for (item in list) {
        to.append(item.toString()) // Java 會要求我們在這裏捕獲 IOException
    }
}

對象方法

當 Java 類型導入到 Kotlin 中時，類型 java.lang.Object 的所有引用都成了 Any。
而因爲 Any 不是平臺指定的，它只聲明瞭 toString()、hashCode() 和 equals() 作爲其成員，
所以爲了能用到 java.lang.Object 的其他成員，Kotlin 要用到擴展函數。

wait()/notify()

Effective Java 第 69 條善意地建議優先使用併發工具(concurrency utilities)而不是 wait() 和 notify()。
因此，類型 Any 的引用不提供這兩個方法。
如果你真的需要調用它們的話，你可以將其轉換爲 java.lang.Object：

(foo as java.lang.Object).wait()

getClass()

要取得對象的 Java 類，請在類引用上使用 java 擴展屬性。

val fooClass = foo::class.java

上面的代碼使用了自 Kotlin 1.1 起支持的綁定的類引用。你也可以使用 javaClass 擴展屬性。

val fooClass = foo.javaClass

clone()

要覆蓋 clone()，需要繼承 kotlin.Cloneable：


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

不要忘記 Effective Java 的第 11 條: 謹慎地改寫clone。

finalize()

要覆蓋 finalize()，所有你需要做的就是簡單地聲明它，而不需要 override{:.keyword} 關鍵字：

class C {
    protected fun finalize() {
        // 終止化邏輯
    }
}

根據 Java 的規則，finalize() 不能是 private{: .keyword } 的。

從 Java 類繼承

在 kotlin 中，類的超類中最多隻能有一個 Java 類(以及按你所需的多個 Java 接口)。

訪問靜態成員

Java 類的靜態成員會形成該類的「伴生對象」。我們無法將這樣的「伴生對象」作爲值來傳遞，
但可以顯式訪問其成員，例如：

if (Character.isLetter(a)) {
    // ……
}

Java 反射

Java 反射適用於 Kotlin 類，反之亦然。如上所述，你可以使用 instance::class.java,
ClassName::class.java 或者 instance.javaClass 通過 java.lang.Class 來進入 Java 反射。

其他支持的情況包括爲一個 Kotlin 屬性獲取一個 Java 的 getter/setter 方法或者幕後字段、爲一個 Java 字段獲取一個 KProperty、爲一個 KFunction 獲取一個 Java 方法或者構造函數，反之亦然。

SAM 轉換

就像 Java 8 一樣，Kotlin 支持 SAM 轉換。這意味着 Kotlin 函數字面值可以被自動的轉換成
只有一個非默認方法的 Java 接口的實現，只要這個方法的參數類型
能夠與這個 Kotlin 函數的參數類型相匹配。

你可以這樣創建 SAM 接口的實例：

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") }

如果 Java 類有多個接受函數式接口的方法，那麼可以通過使用
將 lambda 表達式轉換爲特定的 SAM 類型的適配器函數來選擇需要調用的方法。這些適配器函數也會按需
由編譯器生成。

executor.execute(Runnable { println("This runs in a thread pool") })

請注意，SAM 轉換隻適用於接口，而不適用於抽象類，即使這些抽象類也只有一個
抽象方法。

還要注意，此功能只適用於 Java 互操作；因爲 Kotlin 具有合適的函數類型，所以不需要將函數自動轉換
爲 Kotlin 接口的實現，因此不受支持。

在 Kotlin 中使用 JNI

要聲明一個在本地(C 或 C++)代碼中實現的函數，你需要使用 external 修飾符來標記它：

external fun foo(x: Int): Double

其餘的過程與 Java 中的工作方式完全相同。

Kotlin教程

控制流程

基礎

類和對象

函數

函數和 Lambda 表達式

數組

字符串

高級部分

異常處理

Java/JS互操作

其它

空安全

集合

常見問題回答

註解

反射

Kotlin OOP

範圍

Java互操作性

正則表達式

Getter 和 Setter

返回 void 的方法

將 Kotlin 中是關鍵字的 Java 標識符進行轉義

空安全和平臺類型

平臺類型表示法

可空性註解

已映射類型

Kotlin 中的 Java 泛型

Java 數組

Java 可變參數

操作符

受檢異常

對象方法

wait()/notify()

getClass()

clone()

finalize()

從 Java 類繼承

訪問靜態成員

Java 反射

SAM 轉換

在 Kotlin 中使用 JNI