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

calendar.firstDayOfWeek выше является примером синтетического свойства.

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

Ссылки на синтетические свойства Java

Начиная с Kotlin 1.8.20, вы можете создавать ссылки на синтетические свойства Java. Рассмотрим следующий код Java:

public class Person {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

Kotlin всегда позволял вам писать person.age, где age является синтетическим свойством. Теперь вы также можете создавать ссылки на Person::age и person::age. То же самое относится к name, тоже.

val persons = listOf(Person("Jack", 11), Person("Sofie", 12), Person("Peter", 11))
    Persons
         // Call a reference to Java synthetic property:
        .sortedBy(Person::age)
         // Call Java getter via the Kotlin property syntax:
        .forEach { person -> println(person.name) }
}

tasks
    .withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask<*>>()
    .configureEach {
        compilerOptions
            .languageVersion
            .set(
                org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_2_1
            )
    }

tasks
    .withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask.class)
    .configureEach {
        compilerOptions.languageVersion
            = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_2_1
}

Методы, возвращающие 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.

Другие поддерживаемые случаи включают получение метода getter/setter 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

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

external fun foo(x: Int): Double

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

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

var myProperty: String
    external get
    external set

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

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

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