Вызов 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...
    }
}

В этом случае вам необходимо использовать оператор spread * для передачи 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

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