Quel est l'équivalent des méthodes statiques Java en Kotlin ?

Question

Il n'y a pas static en Kotlin.

Quelle est la meilleure façon de représenter un static Méthode Java en Kotlin ?

Answer 1

Vous placez la fonction dans l'"objet compagnon".

Donc le code java est comme ceci :

class Foo {
  public static int a() { return 1; }
}

deviendra

class Foo {
  companion object {
     fun a() : Int = 1
  }
}

Vous pouvez ensuite l'utiliser à l'intérieur du code Kotlin en tant que

Foo.a();

Mais dans le code Java, vous devrez l'appeler en tant que

Foo.Companion.a();

(Ce qui fonctionne également à partir de Kotlin).

Si vous n'aimez pas avoir à spécifier l'option Companion vous pouvez soit ajouter un @JvmStatic ou nommez votre classe d'accompagnement.

De la docs :

Objets compagnons

Une déclaration d'objet à l'intérieur d'une classe peut être marquée avec l'attribut companion mot-clé :

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 la classe. comme qualificatif :

val instance = MyClass.create()

...

Cependant, sur la JVM, vous pouvez avoir des membres d'objets compagnons générés en tant que méthodes et champs statiques réels, si vous utilisez l'attribut @JvmStatic annotation. Voir le Interopérabilité de Java pour plus de détails.

Ajout de la @JvmStatic ressemble à ceci

class Foo {
  companion object {
    @JvmStatic
    fun a() : Int = 1;
  }
}

et elle existera alors comme une véritable fonction statique Java, accessible à partir de à la fois de Java et de Kotlin comme Foo.a() .

Si elle n'est pas appréciée uniquement pour le Companion vous pouvez également fournir un nom explicite pour l'objet compagnon ressemble à ceci :

class Foo {
  companion object Blah {
    fun a() : Int = 1;
  }
}

qui vous permettra de l'appeler depuis Kotlin de la même manière, mais depuis java comme Foo.Blah.a() (qui fonctionnera également en Kotlin).

Answer 2

Docs recommande de résoudre la plupart des besoins en matière de fonctions statiques à l'aide de fonctions au niveau du paquet . 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() = {}

Utilisation

import foo.bar

Ou bien

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 paquet, la fonction sera accessible à partir de la racine.

Si vous n'avez que de l'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 supporte les méthodes en dehors des classes.

Modifier : Ils ont modifié la documentation pour ne plus inclure la phrase concernant la recommandation de fonctions au niveau du paquet. Este est l'original auquel il a été fait référence ci-dessus.

Answer 3

A. Old Java Way :

1. Déclarer un companion object pour enfermer un méthode / variable

   class Foo{
   companion object {
       fun foo() = println("Foo")
       val bar ="bar"  
       }
   }

2. Utilisez :

   Foo.foo()        // Outputs Foo    
   println(Foo.bar) // Outputs bar

---

---

B. Nouvelle voie Kotlin

1. Déclarer directement sur le fichier sans classe sur un .kt fichier.

   fun foo() = println("Foo")
   val bar ="bar"

2. Utilisez le methods/variables avec leur noms . ( Après les avoir importés )

   Utilisez :

   foo()        // Outputs Foo          
   println(bar) // Outputs bar     

---

Answer 4

Utilisez objet pour représenter val/var/méthode pour rendre statique. Vous pouvez également utiliser un objet au lieu d'une classe singleton. Vous pouvez utiliser compagnon si vous vouliez faire du 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);

En Kotlin, ignorez INSTANCE.

Answer 5

Vous devez passer l'objet compagnon pour la méthode statique car Kotlin n'a pas de mot clé static - Les membres de l'objet compagnon peuvent être appelés en utilisant simplement le nom de la classe comme qualificateur :

package xxx
    class ClassName {
              companion object {
                       fun helloWord(str: String): String {
                            return stringValue
                      }
              }
    }