Il n'y a pas de static
mot-clé dans Kotlin.
Quelle est la meilleure façon de représenter une static
méthode Java dans Kotlin?
Il n'y a pas de static
mot-clé dans Kotlin.
Quelle est la meilleure façon de représenter une static
méthode Java dans Kotlin?
Réponses:
Vous placez la fonction dans "l'objet compagnon".
Donc, le code java comme celui-ci:
class Foo {
public static int a() { return 1; }
}
va devenir
class Foo {
companion object {
fun a() : Int = 1
}
}
Vous pouvez ensuite l'utiliser à partir du code Kotlin comme
Foo.a();
Mais à partir du code Java, vous devez l'appeler comme
Foo.Companion.a();
(Qui fonctionne également depuis Kotlin.)
Si vous n'aimez pas avoir à spécifier le Companion
bit, vous pouvez soit ajouter une @JvmStatic
annotation, soit nommer votre classe compagnon.
De la documentation :
Objets compagnons
Une déclaration d'objet à l'intérieur d'une classe peut être marquée avec le mot-clé compagnon:
class MyClass { companion object Factory { fun create(): MyClass = MyClass() } }
Les membres de l'objet compagnon peuvent être appelés en utilisant simplement le nom de classe comme qualificatif:
val instance = MyClass.create()
...
Cependant, sur la JVM, vous pouvez générer des membres d'objets compagnons en tant que véritables méthodes et champs statiques, si vous utilisez l'
@JvmStatic
annotation. Voir la section sur l'interopérabilité Java pour plus de détails.
L'ajout de l' @JvmStatic
annotation ressemble à ceci
class Foo {
companion object {
@JvmStatic
fun a() : Int = 1;
}
}
puis il existera comme une véritable fonction statique Java, accessible à partir de Java et Kotlin as Foo.a()
.
S'il n'est pas aimé pour le Companion
nom, vous pouvez également fournir un nom explicite pour l'objet compagnon qui ressemble à ceci:
class Foo {
companion object Blah {
fun a() : Int = 1;
}
}
qui vous permettra de l'appeler à partir de Kotlin de la même manière, mais à partir de java like Foo.Blah.a()
(qui fonctionnera également dans Kotlin).
fun a(): Int { return 1 }
ou mêmefun a(): Int = 1
fun a() = 1
.
Factory
est le nom de l'objet compagnon - mais à quoi cela peut-il servir? Je n'en ai aucune idée, mais j'étais intéressé alors j'ai créé une question dédiée à cela: stackoverflow.com/q/45853459/221955 .
Docs recommande de résoudre la plupart des besoins en fonctions statiques avec des fonctions au niveau du package . Ils sont simplement déclarés en dehors d'une classe dans un fichier de code source. Le package d'un fichier peut être spécifié au début d'un fichier avec le mot-clé package.
Déclaration
package foo
fun bar() = {}
Usage
import foo.bar
Alternativement
import foo.*
Vous pouvez maintenant appeler la fonction avec:
bar()
ou si vous n'utilisez pas le mot clé import:
foo.bar()
Si vous ne spécifiez pas le package, la fonction sera accessible depuis la racine.
Si vous n'avez qu'une expérience avec Java, cela peut sembler un peu étrange. La raison en est que kotlin n'est pas un langage strictement orienté objet. On pourrait dire qu'il prend en charge les méthodes en dehors des classes.
Modifier: ils ont modifié la documentation pour ne plus inclure la phrase sur la recommandation de fonctions au niveau du package. Il s'agit de l'original mentionné ci-dessus.
class FooPackage
avec toutes les propriétés et fonctions de niveau supérieur et acheminerait toutes vos références de manière appropriée. Plus d'informations de jetbrains.
bar()
n'a pas d'importance le nom du fichier, vous pouvez le nommer BarUtils.kt
ou quoi que ce soit, puis comme le texte le dit, vous l'importerez avec avecimport <package name>.bar
A. Old Java Way:
Déclarez a companion object
pour inclure une méthode / variable statique
class Foo{
companion object {
fun foo() = println("Foo")
val bar ="bar"
}
}
Utilisation :
Foo.foo() // Outputs Foo
println(Foo.bar) // Outputs bar
B. Nouvelle voie Kotlin
Déclarez directement sur un fichier sans classe sur un .kt
fichier.
fun foo() = println("Foo")
val bar ="bar"
Utilisez le methods/variables
avec leurs noms . ( Après les avoir importés )
Utilisation :
foo() // Outputs Foo
println(bar) // Outputs bar
INSTANCE
mot - clé, comme ceci:Foo.INSTANCE.sayFoo()
static CLASS
pas juste static methdos
. Parce qu'avec les objets compagnons, vous pouvez toujours instancier la classe parent.
val
n'est pas statique, c'est l'équivalent de static final
Java
Utilisez objet pour représenter val / var / méthode pour rendre statique. Vous pouvez également utiliser l'objet au lieu de la classe singleton. Vous pouvez utiliser un compagnon si vous souhaitez rendre statique à l'intérieur d'une classe
object Abc{
fun sum(a: Int, b: Int): Int = a + b
}
Si vous devez l'appeler depuis Java:
int z = Abc.INSTANCE.sum(x,y);
Dans Kotlin, ignorez INSTANCE.
object objectName {
fun funName() {
}
}
Vous devez passer l'objet compagnon pour la méthode statique car kotlin n'a pas de mot clé statique - Les membres de l'objet compagnon peuvent être appelés en utilisant simplement le nom de classe comme qualificatif:
package xxx
class ClassName {
companion object {
fun helloWord(str: String): String {
return stringValue
}
}
}
Il y a 2 façons d'appliquer la statique dans Kotlin
Créez d'abord un objet compagnon sous la classe
Par exemple:
class Test{
companion object{
fun isCheck(a:Int):Boolean{
if(a==0) true else false
}
}
}
vous pouvez appeler cette fonction
Test.Companion.isCheck(2)
Une autre façon que nous pouvons utiliser est de créer une classe d'objets
object Test{
fun isCheck(a:Int):Boolean{
if(a==0) true else false
}
}
Codage heureux!
Test.Companion.isCheck(2)
), l'EDI affiche des avertissements et dit Companion reference is redundant
. Il peut être réduit à Test.isCheck(2)
et la forme réduite est plus proche de l'équivalent java.
Kotlin n'a pas de mot-clé statique. Vous l'avez utilisé pour java
class AppHelper {
public static int getAge() {
return 30;
}
}
et pour Kotlin
class AppHelper {
companion object {
fun getAge() : Int = 30
}
}
Appel à Java
AppHelper.getAge();
Appel à Kotlin
AppHelper.Companion.getAge();
Je pense que cela fonctionne parfaitement.
Je voudrais ajouter quelque chose aux réponses ci-dessus.
Oui, vous pouvez définir des fonctions dans des fichiers de code source (hors classe). Mais il vaut mieux que vous définissiez des fonctions statiques à l'intérieur de la classe à l'aide de Companion Object car vous pouvez ajouter plus de fonctions statiques en tirant parti des extensions Kotlin .
class MyClass {
companion object {
//define static functions here
}
}
//Adding new static function
fun MyClass.Companion.newStaticFunction() {
// ...
}
Et vous pouvez appeler la fonction définie ci-dessus comme vous appellerez n'importe quelle fonction à l'intérieur de Companion Object.
Même si cela fait un peu plus de 2 ans maintenant, et a eu beaucoup de bonnes réponses, je constate qu'il manque d'autres façons d'obtenir des champs Kotlin "statiques". Voici un exemple de guide pour l' static
interopérabilité Kotlin-Java :
Scénario 1: Création d'une méthode statique dans Kotlin pour Java
Kotlin
@file:JvmName("KotlinClass") //This provides a name for this file, so it's not defaulted as [KotlinClassKt] in Java package com.frybits class KotlinClass { companion object { //This annotation tells Java classes to treat this method as if it was a static to [KotlinClass] @JvmStatic fun foo(): Int = 1 //Without it, you would have to use [KotlinClass.Companion.bar()] to use this method. fun bar(): Int = 2 } }
Java
package com.frybits; class JavaClass { void someFunction() { println(KotlinClass.foo()); //Prints "1" println(KotlinClass.Companion.bar()); //Prints "2". This is the only way to use [bar()] in Java. println(KotlinClass.Companion.foo()); //To show that [Companion] is still the holder of the function [foo()] } //Because I'm way to lazy to keep typing [System.out], but I still want this to be compilable. void println(Object o) { System.out.println(o); } }
La réponse de Michael Anderson fournit plus de profondeur que cela et devrait certainement être référencée pour ce scénario.
Ce scénario suivant gère la création de champs statiques dans Kotlin afin que Java n'ait pas à continuer d'appeler KotlinClass.foo()
dans les cas où vous ne voulez pas de fonction statique.
Scénario 2: création d'une variable statique dans Kotlin pour Java
Kotlin
@file:JvmName("KotlinClass") //This provides a name for this file, so it's not defaulted as [KotlinClassKt] in Java package com.frybits class KotlinClass { companion object { //This annotation tells Kotlin to not generate the getter/setter functions in Java. Instead, this variable should be accessed directly //Also, this is similar to [@JvmStatic], in which it tells Java to treat this as a static variable to [KotlinClass]. @JvmField var foo: Int = 1 //If you want something akin to [final static], and the value is a primitive or a String, you can use the keyword [const] instead //No annotation is needed to make this a field of [KotlinClass]. If the declaration is a non-primitive/non-String, use @JvmField instead const val dog: Int = 1 //This will be treated as a member of the [Companion] object only. It generates the getter/setters for it. var bar: Int = 2 //We can still use [@JvmStatic] for 'var' variables, but it generates getter/setters as functions of KotlinClass //If we use 'val' instead, it only generates a getter function @JvmStatic var cat: Int = 9 } }
Java
package com.frybits; class JavaClass { void someFunction() { //Example using @JvmField println(KotlinClass.foo); //Prints "1" KotlinClass.foo = 3; //Example using 'const val' println(KotlinClass.dog); //Prints "1". Notice the lack of a getter function //Example of not using either @JvmField, @JvmStatic, or 'const val' println(KotlinClass.Companion.getBar()); //Prints "2" KotlinClass.Companion.setBar(3); //The setter for [bar] //Example of using @JvmStatic instead of @JvmField println(KotlinClass.getCat()); KotlinClass.setCat(0); } void println(Object o) { System.out.println(o); } }
L'une des grandes fonctionnalités de Kotlin est que vous pouvez créer des fonctions et des variables de haut niveau. Cela le rend idéal pour créer des listes "sans classe" de champs et fonctions constants, qui à leur tour peuvent être utilisés comme static
fonctions / champs en Java.
Scénario 3: Accès aux champs et fonctions de niveau supérieur dans Kotlin à partir de Java
Kotlin
//In this example, the file name is "KSample.kt". If this annotation wasn't provided, all functions and fields would have to accessed //using the name [KSampleKt.foo()] to utilize them in Java. Make life easier for yourself, and name this something more simple @file:JvmName("KotlinUtils") package com.frybits //This can be called from Java as [KotlinUtils.TAG]. This is a final static variable const val TAG = "You're it!" //Since this is a top level variable and not part of a companion object, there's no need to annotate this as "static" to access in Java. //However, this can only be utilized using getter/setter functions var foo = 1 //This lets us use direct access now @JvmField var bar = 2 //Since this is calculated at runtime, it can't be a constant, but it is still a final static variable. Can't use "const" here. val GENERATED_VAL:Long = "123".toLong() //Again, no need for @JvmStatic, since this is not part of a companion object fun doSomethingAwesome() { println("Everything is awesome!") }
Java
package com.frybits; class JavaClass { void someFunction() { println(KotlinUtils.TAG); //Example of printing [TAG] //Example of not using @JvmField. println(KotlinUtils.getFoo()); //Prints "1" KotlinUtils.setFoo(3); //Example using @JvmField println(KotlinUtils.bar); //Prints "2". Notice the lack of a getter function KotlinUtils.bar = 3; //Since this is a top level variable, no need for annotations to use this //But it looks awkward without the @JvmField println(KotlinUtils.getGENERATED_VAL()); //This is how accessing a top level function looks like KotlinUtils.doSomethingAwesome(); } void println(Object o) { System.out.println(o); } }
Une autre mention notable qui peut être utilisée en Java comme champs "statiques" est les object
classes Kotlin . Ce sont des classes singleton à paramètre zéro qui sont instanciées paresseusement lors de la première utilisation. Plus d'informations à leur sujet peuvent être trouvées ici: https://kotlinlang.org/docs/reference/object-declarations.html#object-declarations
Cependant, pour accéder au singleton, un INSTANCE
objet spécial est créé, qui est tout aussi encombrant à gérer qu'il l' Companion
est. Voici comment utiliser des annotations pour lui donner une static
sensation de pureté en Java:
Scénario 4: utiliser des
object
classesKotlin
@file:JvmName("KotlinClass") //This provides a name for this file, so it's not defaulted as [KotlinClassKt] in Java package com.frybits object KotlinClass { //No need for the 'class' keyword here. //Direct access to this variable const val foo: Int = 1 //Tells Java this can be accessed directly from [KotlinClass] @JvmStatic var cat: Int = 9 //Just a function that returns the class name @JvmStatic fun getCustomClassName(): String = this::class.java.simpleName + "boo!" //Getter/Setter access to this variable, but isn't accessible directly from [KotlinClass] var bar: Int = 2 fun someOtherFunction() = "What is 'INSTANCE'?" }
Java
package com.frybits; class JavaClass { void someFunction() { println(KotlinClass.foo); //Direct read of [foo] in [KotlinClass] singleton println(KotlinClass.getCat()); //Getter of [cat] KotlinClass.setCat(0); //Setter of [cat] println(KotlinClass.getCustomClassName()); //Example of using a function of this 'object' class println(KotlinClass.INSTANCE.getBar()); //This is what the singleton would look like without using annotations KotlinClass.INSTANCE.setBar(23); println(KotlinClass.INSTANCE.someOtherFunction()); //Accessing a function in the object class without using annotations } void println(Object o) { System.out.println(o); } }
Pour faire court, vous pouvez utiliser "objet compagnon" pour entrer dans le monde statique de Kotlin comme:
companion object {
const val TAG = "tHomeFragment"
fun newInstance() = HomeFragment()
}
et pour faire un champ constant, utilisez "const val" comme dans le code. mais essayez d'éviter les classes statiques car cela rend difficile les tests unitaires avec Mockito !.
La conversion exacte de la méthode statique java en équivalent kotlin serait la suivante. Par exemple, ici, la classe util a une méthode statique qui serait équivalente à la fois en java et en kotlin. L'utilisation de @JvmStatic est importante.
Code Java:
class Util{
public static String capitalize(String text){
return text.toUpperCase();}
}
Code Kotlin:
class Util {
companion object {
@JvmStatic
fun capitalize(text:String): String {
return text.toUpperCase()
}
}
}
Il vous suffit de créer un objet compagnon et d'y mettre la fonction
class UtilClass {
companion object {
// @JvmStatic
fun repeatIt5Times(str: String): String = str.repeat(5)
}
}
Pour appeler la méthode à partir d'une classe kotlin:
class KotlinClass{
fun main(args : Array<String>) {
UtilClass.repeatIt5Times("Hello")
}
}
ou en utilisant l'importation
import Packagename.UtilClass.Companion.repeatIt5Times
class KotlinClass{
fun main(args : Array<String>) {
repeatIt5Times("Hello")
}
}
Pour appeler la méthode à partir d'une classe java:
class JavaClass{
public static void main(String [] args){
UtilClass.Companion.repeatIt5Times("Hello");
}
}
ou en ajoutant une annotation @JvmStatic à la méthode
class JavaClass{
public static void main(String [] args){
UtilClass.repeatIt5Times("Hello")
}
}
ou les deux en ajoutant une annotation @JvmStatic à la méthode et en effectuant une importation statique en java
import static Packagename.UtilClass.repeatIt5Times
class JavaClass{
public static void main(String [] args){
repeatIt5Times("Hello")
}
}
Pour Java:
public class Constants {
public static final long MAX_CLICK_INTERVAL = 1000;}
Code Kotlin équivalent:
object Constants {
const val MAX_CLICK_INTERVAL: Long = 1000}
Donc, pour l'équivalent des méthodes statiques Java, il y a la classe d'objets dans Kotlin.
Pour Android en utilisant une chaîne d'une seule activité à toute l'activité nécessaire. Tout comme statique en java
public final static String TEA_NAME = "TEA_NAME";
Approche équivalente dans Kotlin:
class MainActivity : AppCompatActivity() {
companion object {
const val TEA_NAME = "TEA_NAME"
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
}
Une autre activité où la valeur est nécessaire:
val teaName = MainActivity.TEA_NAME
à l'exception de la réponse de Michael Anderson, j'ai du codage avec deux autres voies dans mon projet.
vous pouvez blanchir toutes les variables dans une seule classe. créé un fichier kotlin nommé Const
object Const {
const val FIRST_NAME_1 = "just"
const val LAST_NAME_1 = "YuMu"
}
Vous pouvez l'utiliser en code kotlin et java
Log.d("stackoverflow", Const.FIRST_NAME_1)
Vous pouvez utiliser la fonction d'extension de Kotlin
créé un fichier kotlin nommé Ext , ci-dessous le code est tout le code dans le fichier Ext
package pro.just.yumu
/**
* Created by lpf on 2020-03-18.
*/
const val FIRST_NAME = "just"
const val LAST_NAME = "YuMu"
Vous pouvez l'utiliser en code kotlin
Log.d("stackoverflow", FIRST_NAME)
Vous pouvez l'utiliser en code java
Log.d("stackoverflow", ExtKt.FIRST_NAME);
Écrivez-les directement dans les fichiers.
En Java (moche):
package xxx;
class XxxUtils {
public static final Yyy xxx(Xxx xxx) { return xxx.xxx(); }
}
À Kotlin:
@file:JvmName("XxxUtils")
package xxx
fun xxx(xxx: Xxx): Yyy = xxx.xxx()
Ces deux morceaux de codes sont égalés après la compilation (même le nom de fichier compilé, le file:JvmName
est utilisé pour contrôler le nom de fichier compilé, qui doit être placé juste avant la déclaration du nom du package).
Utilisation @JVMStatic
annotation
companion object {
// TODO: Rename and change types and number of parameters
@JvmStatic
fun newInstance(param1: String, param2: String) =
EditProfileFragment().apply {
arguments = Bundle().apply {
putString(ARG_PARAM1, param1)
putString(ARG_PARAM2, param2)
}
}
}
Soit, vous avez un étudiant de classe . Et vous avez une méthode statique getUniversityName () et un champ statique appelé totalStudent .
Vous devez déclarer le bloc d' objet compagnon dans votre classe.
companion object {
// define static method & field here.
}
Ensuite, votre classe ressemble
class Student(var name: String, var city: String, var rollNumber: Double = 0.0) {
// use companion object structure
companion object {
// below method will work as static method
fun getUniversityName(): String = "MBSTU"
// below field will work as static field
var totalStudent = 30
}
}
Ensuite, vous pouvez utiliser ces méthodes et champs statiques de cette façon.
println("University : " + Student.getUniversityName() + ", Total Student: " + Student.totalStudent)
// Output:
// University : MBSTU, Total Student: 30
Il n'y a pas de mot clé statique dans kotlin. kotlin docs recommande d'utiliser des fonctions au niveau du package si vous souhaitez suivre DRY. Créez un fichier avec l' extension .kt et mettez-y votre méthode.
package p
fun m(){
//fun body
}
après la compilation m aura une signature de vide final statique public
et
import p.m
☺
Vous pouvez obtenir la fonctionnalité statique dans Kotlin by Companion Objects
Un objet compagnon ne peut pas être déclaré en dehors de la classe.
class MyClass{
companion object {
val staticField = "This is an example of static field Object Decleration"
fun getStaticFunction(): String {
return "This is example of static function for Object Decleration"
}
}
}
Les membres de l'objet compagnon peuvent être appelés en utilisant simplement le nom de classe comme qualificatif:
Production:
MyClass.staticField // This is an example of static field Object Decleration
MyClass.getStaticFunction() : // This is an example of static function for Object Decleration
Beaucoup de gens mentionnent des objets compagnons, ce qui est correct. Mais, juste pour que vous le sachiez, vous pouvez également utiliser n'importe quel type d'objet (en utilisant le mot-clé objet, pas une classe), c'est-à-dire,
object StringUtils {
fun toUpper(s: String) : String { ... }
}
Utilisez-le comme n'importe quelle méthode statique en java:
StringUtils.toUpper("foobar")
Ce type de modèle est cependant un peu inutile dans Kotlin, l'une de ses forces est qu'il supprime le besoin de classes remplies de méthodes statiques. Il est plus approprié d'utiliser à la place des fonctions globales, d'extension et / ou locales, selon votre cas d'utilisation. Là où je travaille, nous définissons souvent des fonctions d'extension globale dans un fichier plat séparé avec la convention de dénomination: [className] Extensions.kt, c'est-à-dire FooExtensions.kt. Mais plus généralement, nous écrivons des fonctions là où elles sont nécessaires dans leur classe d'exploitation ou leur objet.
En Java, nous pouvons écrire ci-dessous
class MyClass {
public static int myMethod() {
return 1;
}
}
Dans Kotlin, nous pouvons écrire ci-dessous
class MyClass {
companion object {
fun myMethod() : Int = 1
}
}
un compagnon est utilisé comme statique dans Kotlin.
Le fournisseur de documents kotlin propose trois façons de le faire, la première consiste à définir la fonction dans un package, sans classe:
package com.example
fun f() = 1
la seconde consiste à utiliser l'annotation @JvmStatic:
package com.example
class A{
@JvmStatic
fun f() = 1
}
et le troisième est d'utiliser l'objet compagnon:
package com.example
clss A{
companion object{
fun f() = 1
}
}
Si vous avez besoin d'une fonction ou d'une propriété à lier à une classe plutôt qu'à ses instances, vous pouvez la déclarer dans un objet compagnon:
class Car(val horsepowers: Int) {
companion object Factory {
val cars = mutableListOf<Car>()
fun makeCar(horsepowers: Int): Car {
val car = Car(horsepowers)
cars.add(car)
return car
}
}
}
L'objet compagnon est un singleton, et ses membres sont accessibles directement via le nom de la classe conteneur
val car = Car.makeCar(150)
println(Car.Factory.cars.size)
Vous pouvez utiliser des objets compagnons - kotlinlang
Qu'il peut être montré en créant d'abord cette interface
interface I<T> {
}
Ensuite, nous devons créer une fonction à l'intérieur de cette interface:
fun SomeFunc(): T
Ensuite, nous avons besoin d'une classe:
class SomeClass {}
à l'intérieur de cette classe, nous avons besoin d'un objet compagnon à l'intérieur de cette classe:
companion object : I<SomeClass> {}
à l'intérieur de cet objet compagnon, nous avons besoin de cette ancienne SomeFunc
fonction, mais nous devons la dépasser:
override fun SomeFunc(): SomeClass = SomeClass()
Enfin, en dessous de tout ce travail, nous avons besoin de quelque chose pour alimenter cette fonction statique, nous avons besoin d'une variable:
var e:I<SomeClass> = SomeClass()