Beim Aufrufen von Kotlin-Code aus Java

Standardargument

Wenn Sie Kotlins Funktionen mit Standardargumenten aus Java behandeln möchten, müssen Sie alle Argumente angeben. Wenn Sie der Funktion jedoch die Annotation @ JvmOverload hinzufügen, wird die Überladungsmethode automatisch generiert.

// Kotlin
class OverloadSample {
    @JvmOverloads //Durch Annotieren wird eine überladene Methode generiert, die von Java aus aufgerufen werden kann
    fun test(arg1: Boolean = true, arg2: Int = 1, arg3: String = "true") : Boolean {
        return arg1 && arg2 == 1 && arg3 == "true"
    }
}

Lassen Sie uns den Aufrufcode von Java implementieren.

// Java
OverloadSample os = new OverloadSample();
os.test(true, 1, "true");
os.test(true, 1);
os.test(true);

Funktionen, Eigenschaften der obersten Ebene

Aufrufen von Kotlin-Funktionen der obersten Ebene, die nicht zu einer Klasse gehören, aus Java. Kotlins Top-Level-Funktionen Eine Klasse mit dem Namen "Quelldateiname + Kt" wird generiert Es wird in eine statische Funktion dieser Klasse kompiliert.

// Utility.kt
fun doSomething() {
    // Do something
}

// Java
UtilityKt.doSomething();

Wenn Sie den obigen Klassennamen Quelldateiname + Kt ändern möchten, verwenden Sie die Annotation @ JvmName. Diese Anmerkung ist im Paket beschrieben.

// Utility.kt
@file: JvmName("Util")
package com.sample

fun doSomething() {
    // Do something
}

// Java
Util.doSomething();

Erweiterungsfunktion

Erweiterungsfunktionen werden wie Funktionen der obersten Ebene als statische Funktionen der Klasse "Quelldateiname + Kt" kompiliert. Beim Aufruf von Java ist das Objekt, das dies wird, das erste Argument.

// StringUtility.kt
fun String.join(otherString: String) : String {
    return this + otherString
}

// Java
StringUtilityKt.join("Hello, ", "World!");

Objektklasse

Bei der Objektklasse aus Java handelt es sich um eine Klasse mit einem statischen Feld namens "INSTANCE". Um auf die Eigenschaften oder Funktionen der Objektklasse zuzugreifen, gehen Sie diese INSTANCE durch.

// Kotlin
object LogUtil {
    fun debug(log: String) {
        //
    }
}

// Java
LogUtil.INSTANCE.debug("completed!");

Beim Aufrufen von Java-Code aus Kotlin

Plattformtyp

Zum Beispiel beim Empfang des Rückgabewerts einer Java-Funktion in Kotlin-Code Ob der Rückgabewert nullbar ist oder nicht, hängt von "@ NonNull" und "@ Nullable" ab. Es wird anhand der Anmerkung beurteilt.

// Java
public class Sample {

    @NonNull
    String getString1() {
        return //
    }

    @Nullable
    String getString2() {
        return //
    }
}

Wenn man mit Kotlin anruft, sieht es so aus:

// Kotlin
val sample = Sample()
val str1 = sample.string1 //Nicht null akzeptabler Typ
val str2 = sample.string2 //null-toleranter Typ

Die Anmerkungen "@ NonNull" und "@ Nullable" Bitte beachten Sie, dass es zum Zeitpunkt der Kompilierung nicht durchsetzbar ist.

Wenn Sie also keine Anmerkungen hinzufügen ...

// Java
public class Sample {
    //Keine Anmerkung
    String getString3() {
        return  //
    }
}

Nennen wir es von Kotlin.

// Kotlin
val sample = Sample()
val str3 = sample.string3 // String!

Der Typ ist "String!". Der Typ mit ! Wird als Plattformtyp bezeichnet.

Beide Typen können sowohl nulltolerante als auch nicht nulltolerante Typen verarbeiten. Die Idee ist, es dem Entwickler zu überlassen, zu entscheiden, ob es Null ist oder nicht.

// Kotlin
val sample = Sample()
val str = sample.string3
val length = str.length //Als nicht null tolerant behandeln
val char = str?.get(0) //Als nulltoleranten Typ behandeln

statische Funktion, statisches Feld

Es kann Situationen geben, in denen Sie aus irgendeinem Grund eine statische Funktion oder ein statisches Feld benötigen. Zum Beispiel ...

Begleitobjekt, das in Kotlin wie statisch verwendet werden kann. Wenn Sie hier Anmerkungen verwenden, werden diese als Java-Statik kompiliert.

// Kotlin
class Sample {
    companion object {

        @JvmField //Eine Anmerkung, die die Kompilierung eines statischen Felds angibt
        var TAG: String = "Sample"

        @JvmStatic //Anmerkung, die die Kompilierung einer statischen Funktion angibt
        fun tag(): String {
            return "Sample"
        }
    }
}

// Java
String tag = Sample.TAG;
tag = Sample.tag();

SAM-Konvertierung

Unter bestimmten Bedingungen Sie können eine Klasse erstellen, die die Java-Schnittstelle mit einem Lambda-Ausdruck implementiert.

val executor: ThreadPoolExecutor

//Übergeben Sie ein Objekt, das Runnable als Argument der execute-Methode implementiert
executor.execute(object: Runnable{
    override fun run() {
        //
    }
})

//Es kann durch SAM-Konvertierung in einem Lambda-Ausdruck ausgedrückt werden!
executor.execute { 
    //
}

Die Bedingungen, unter denen die SAM-Konvertierung in Kotlin aktiviert ist, sind wie folgt.

Muss eine in Java deklarierte Schnittstelle sein
Muss eine Schnittstelle mit nur einer abstrakten Methode sein

Die SAM-Konvertierung ist in der in Kotlin deklarierten Schnittstelle nicht aktiviert, da in Kotlin ein geeigneter Funktionstyp vorhanden ist

Tipps zur Interoperabilität mit Kotlin zum Senden an Java-Entwickler