Si vous souhaitez gérer les fonctions de Kotlin avec des arguments par défaut de Java, vous devez spécifier tous les arguments.
Cependant, si vous ajoutez l'annotation @ JvmOverload à la fonction, la méthode de surcharge sera générée automatiquement.
// Kotlin
class OverloadSample {
@JvmOverloads //L'annotation générera une méthode surchargée qui peut être appelée à partir de Java
fun test(arg1: Boolean = true, arg2: Int = 1, arg3: String = "true") : Boolean {
return arg1 && arg2 == 1 && arg3 == "true"
}
}
Implémentons le code d'appel de Java.
// Java
OverloadSample os = new OverloadSample();
os.test(true, 1, "true");
os.test(true, 1);
os.test(true);
Comment appeler des fonctions Kotlin de premier niveau qui n'appartiennent pas à une classe depuis Java.
Fonctions de haut niveau de Kotlin
Une classe nommée nom du fichier source + Kt est générée
Il sera compilé dans une fonction statique de cette classe.
// Utility.kt
fun doSomething() {
// Do something
}
// Java
UtilityKt.doSomething();
Si vous souhaitez modifier le nom de classe ci-dessus nom du fichier source + Kt, utilisez l'annotation @ JvmName. Cette annotation est décrite dans le package.
// Utility.kt
@file: JvmName("Util")
package com.sample
fun doSomething() {
// Do something
}
// Java
Util.doSomething();
Les fonctions d'extension, comme les fonctions de niveau supérieur, sont compilées comme des fonctions statiques de la classe nommée nom du fichier source + Kt. Lors d'un appel depuis Java, l'objet qui devient ceci est le premier argument.
// StringUtility.kt
fun String.join(otherString: String) : String {
return this + otherString
}
// Java
StringUtilityKt.join("Hello, ", "World!");
En regardant la classe d'objet de Java, c'est une classe avec un champ statique appelé ʻINSTANCE. Pour accéder aux propriétés ou fonctions de la classe d'objets, parcourez cette ʻINSTANCE.
// Kotlin
object LogUtil {
fun debug(log: String) {
//
}
}
// Java
LogUtil.INSTANCE.debug("completed!");
Par exemple, lors de la réception de la valeur de retour d'une fonction Java dans le code Kotlin
Le fait que la valeur de retour soit tolérante à null ou non dépend de @ NonNull et @ Nullable.
Il est jugé par l'annotation.
// Java
public class Sample {
@NonNull
String getString1() {
return //
}
@Nullable
String getString2() {
return //
}
}
Lorsqu'il est appelé avec Kotlin, cela ressemble à ceci:
// Kotlin
val sample = Sample()
val str1 = sample.string1 //Type acceptable non nul
val str2 = sample.string2 //type à tolérance nulle
Cependant, les annotations @ NonNull et @ Nullable
Veuillez noter qu'il n'est pas exécutoire au moment de la compilation.
Donc, si vous n'ajoutez pas d'annotations ...
// Java
public class Sample {
//Aucune annotation
String getString3() {
return //
}
}
Appelons-le de Kotlin.
// Kotlin
val sample = Sample()
val str3 = sample.string3 // String!
Le type est "String!".
Le type avec ! Est appelé le type de plate-forme.
Les deux types peuvent gérer à la fois les types tolérants à zéro et non tolérants à zéro. L'idée est de laisser au développeur le soin de décider si c'est Null ou non.
// Kotlin
val sample = Sample()
val str = sample.string3
val length = str.length //Traiter comme tolérant non nul
val char = str?.get(0) //Traiter comme un type à tolérance nulle
Il peut y avoir des situations où vous avez besoin d'une fonction ou d'un champ statique pour une raison quelconque. Par exemple ...
Objet compagnon qui peut être utilisé comme statique dans Kotlin.
Si vous utilisez des annotations ici, elles seront compilées en Java statique.
// Kotlin
class Sample {
companion object {
@JvmField //Une annotation qui spécifie la compilation dans un champ statique
var TAG: String = "Sample"
@JvmStatic //Annotation qui spécifie la compilation vers une fonction statique
fun tag(): String {
return "Sample"
}
}
}
// Java
String tag = Sample.TAG;
tag = Sample.tag();
Sous certaines conditions Vous pouvez créer une classe qui implémente l'interface Java avec une expression lambda.
val executor: ThreadPoolExecutor
//Passer un objet qui implémente Runnable comme argument de la méthode execute
executor.execute(object: Runnable{
override fun run() {
//
}
})
//Il peut être exprimé dans une expression lambda par conversion SAM!
executor.execute {
//
}
Les conditions dans lesquelles la conversion SAM est activée dans Kotlin sont les suivantes.
La conversion SAM n'est pas activée dans l'interface déclarée dans Kotlin car il existe un type de fonction approprié dans Kotlin