Вызов Java из Kotlin

Геттеры и сеттеры

Методы, соответствующие соглашениям Java для геттеров и сеттеров (методы без аргументов с именами, начинающимися с get и методы с одним аргументом, начинающиеся с set), представляются в Kotlin как свойства. Boolean методы доступа (где имя геттера начинается с is , а имя сеттера начинается с set ) представляются как свойства, имеющие то же имя, что и метод геттера.

import java.util.Calendar

fun calendarDemo() {
    val calendar = Calendar.getInstance()
    if (calendar.firstDayOfWeek == Calendar.SUNDAY) { // call getFirstDayOfWeek()
        calendar.firstDayOfWeek = Calendar.MONDAY // call setFirstDayOfWeek()
    }
    if (!calendar.isLenient) { // call isLenient()
        calendar.isLenient = true // call setLenient()
    }
}

Обратите внимание, что если класс Java содержит только сеттер, он не отображается как свойство в Kotlin, поскольку Kotlin не поддерживает свойства только для записи.

Методы, возвращающие void

Если метод Java возвращает void, он будет возвращать Unit при вызове из Kotlin. Если кто-то по какой-то причине использует это возвращаемое значение, оно будет присвоено в месте вызова компилятором Kotlin, поскольку значение само по себе известно заранее (будучи Unit).

Обработка идентификаторов Java, являющихся ключевыми словами в Kotlin

Некоторые ключевые слова Kotlin являются допустимыми идентификаторами в Java: in, object, is, и другие. Если Java-библиотека использует ключевое слово Kotlin для метода, вы все равно можете вызвать метод, экранируя его символом обратной косой черты ( ` ):

foo.`is`(bar)

Сопоставленные типы

Kotlin обрабатывает некоторые типы Java особым образом. Такие типы не загружаются из Java "как есть", а сопоставляются с соответствующими типами Kotlin. Сопоставление имеет значение только во время компиляции, представление во время выполнения остается неизменным. Примитивные типы Java сопоставляются с соответствующими типами Kotlin (учитывая платформенные типы):

Также сопоставляются некоторые встроенные классы, не являющиеся примитивными:

Упакованные примитивные типы Java сопоставляются с допускающими NULL типами Kotlin:

Обратите внимание, что упакованный примитивный тип, используемый в качестве параметра типа, сопоставляется с платформенным типом: например, List<java.lang.Integer> становится List<Int!> в Kotlin.

Типы коллекций могут быть только для чтения или изменяемыми в Kotlin, поэтому коллекции Java сопоставляются следующим образом (все типы Kotlin в этой таблице находятся в пакете kotlin.collections) :

Массивы Java сопоставляются, как указано ниже:

Обобщения Java в Kotlin

Обобщения 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, которые учитывают обобщения. Kotlin допускает только проверки is для типов обобщений с проекцией со звездочкой:

if (a is List<Int>) // Error: cannot check if it is really a List of Ints
// but
if (a is List<*>) // OK: no guarantees about the contents of the list

Массивы Java

Массивы в Kotlin неизменяемы, в отличие от Java. Это означает, что Kotlin не позволит вам присвоить Array<String> массиву Array<Any>, что предотвращает возможную ошибку во время выполнения. Передача массива подкласса как массива суперкласса в метод Kotlin также запрещена, но для методов Java это разрешено через типы платформы в формате Array<(out) String>!.

Массивы используются с примитивными типами данных на платформе Java, чтобы избежать затрат на операции boxing/unboxing. Поскольку Kotlin скрывает эти детали реализации, требуется обходной путь для взаимодействия с кодом Java. Существуют специализированные классы для каждого типа примитивного массива (IntArray, DoubleArray, CharArray, и так далее) для обработки этого случая. Они не связаны с классом Array и компилируются в примитивные массивы Java для максимальной производительности.

Предположим, есть метод Java, который принимает массив целых чисел индексов:

public class JavaArrayExample {
    public void removeIndices(int[] indices) {
        // code here...
    }
}

Чтобы передать массив примитивных значений, вы можете сделать следующее в Kotlin:

val javaObj = JavaArrayExample()
val array = intArrayOf(0, 1, 2, 3)
javaObj.removeIndices(array)  // passes int[] to method

При компиляции в байт-код JVM компилятор оптимизирует доступ к массивам, чтобы не было накладных расходов:

val array = arrayOf(1, 2, 3, 4)
array[1] = array[1] * 2 // no actual calls to get() and set() generated
for (x in array) { // no iterator created
    print(x)
}

Даже при навигации по индексу это не приводит к дополнительным накладным расходам:

for (i in array.indices) { // no iterator created
    array[i] += 2
}

Наконец, in-проверки также не имеют накладных расходов:

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

Java varargs

Классы Java иногда используют объявление метода для индексов с переменным количеством аргументов (varargs):

public class JavaArrayExample {

    public void removeIndicesVarArg(int... indices) {
        // code here...
    }
}

В этом случае вам нужно использовать оператор распространения * для передачи IntArray:

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

Операторы

Поскольку Java не имеет возможности отмечать методы, для которых имеет смысл использовать синтаксис оператора, Kotlin позволяет использовать любые методы Java с правильным именем и сигнатурой в качестве перегрузок операторов и других соглашений (invoke() и т. д.). Вызов методов Java с помощью инфиксного синтаксиса вызова запрещен.

Проверенные исключения

В Kotlin все исключения не проверяются, что означает, что компилятор не заставляет вас их перехватывать. Таким образом, при вызове метода Java, объявляющего проверяемое исключение, Kotlin ничего не требует:

fun render(list: List<*>, to: Appendable) {
    for (item in list) {
        to.append(item.toString()) // Java would require us to catch IOException here
    }
}

Методы объектов

При импорте типов Java в Kotlin все ссылки типа java.lang.Object преобразуются в Any. Так как Any не является платформоспецифичным, он объявляет только toString(), hashCode() и equals() как свои члены, поэтому для доступа к другим членам java.lang.Object Kotlin использует расширяющие функции.

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

val fooClass = foo::class.java

val fooClass = foo.javaClass

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

class C {
    protected fun finalize() {
        // finalization logic
    }
}

Наследование от классов Java

Максимум один класс Java (и любое количество интерфейсов Java) может быть супертипом для класса в Kotlin.

Доступ к статическим членам

Статические члены классов Java образуют «объекты-компаньоны» для этих классов. Вы не можете передавать такой «объект-компаньон» как значение, но можете обращаться к членам явно, например:

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

Для доступа к статическим членам типа Java, сопоставленного с типом Kotlin, используйте полное квалифицированное имя типа Java: java.lang.Integer.bitCount(foo).

Рефлексия Java

Рефлексия Java работает с классами Kotlin и наоборот. Как упоминалось выше, вы можете использовать instance::class.java, ClassName::class.java или instance.javaClass для входа в рефлексию Java через java.lang.Class. Не используйте ClassName.javaClass для этой цели, потому что оно относится к классу объекта-компаньона ClassName, который совпадает с ClassName.Companion::class.java, а не с ClassName::class.java.

Для каждого примитивного типа существует два разных класса Java, и Kotlin предоставляет способы получить оба. Например, Int::class.java вернёт экземпляр класса, представляющий сам примитивный тип, соответствующий Integer.TYPE в Java. Чтобы получить класс соответствующего оберточного типа, используйте Int::class.javaObjectType, что эквивалентно Integer.class в Java.

Другие поддерживаемые случаи включают получение метода Java-геттера/сеттера или поля-переменной для свойства Kotlin, KProperty для поля Java, метода или конструктора Java для KFunction и наоборот.

Преобразования SAM

Kotlin поддерживает преобразования SAM для интерфейсов Java и Kotlin. Эта поддержка для Java означает, что литералы функций Kotlin могут автоматически преобразовываться в реализации интерфейсов Java с единственным методом без по умолчанию, при условии, что типы параметров метода интерфейса совпадают с типами параметров функции Kotlin.

Вы можете использовать это для создания экземпляров интерфейсов SAM:

val runnable = Runnable { println("This runs in a runnable") }

...и в вызовах методов:

val executor = ThreadPoolExecutor()
// Java signature: void execute(Runnable command)
executor.execute { println("This runs in a thread pool") }

Если класс Java имеет несколько методов, принимающих функциональные интерфейсы, вы можете выбрать нужный метод, используя адаптерную функцию, которая преобразует лямбда-выражение в конкретный тип SAM. Эти адаптерные функции также генерируются компилятором при необходимости:

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

Использование JNI с Kotlin

Чтобы объявить функцию, реализованную в коде нативных языках (C или C++), необходимо пометить её модификатором external:

external fun foo(x: Int): Double

Остальная часть процедуры работает точно так же, как и в Java.

Вы также можете пометить геттеры и сеттеры свойств как external:

var myProperty: String
    external get
    external set

За кулисами это создаст две функции getMyProperty и setMyProperty, обе помеченные как external.

Использование Lombok-сгенерированных объявлений в Kotlin

Вы можете использовать Java-объявления, сгенерированные Lombok, в Kotlin-коде. Если вам нужно генерировать и использовать эти объявления в одном смешанном Java/Kotlin-модуле, вы можете узнать, как это сделать на странице плагина Lombok для компилятора. Если вы вызываете такие объявления из другого модуля, вам не нужно использовать этот плагин для компиляции этого модуля.