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

Переменное число аргументов (varargs) Java

Классы 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

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