Il n'y a pas de staticmot-clé dans Kotlin.

Quelle est la meilleure façon de représenter une staticméthode Java dans Kotlin?

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 Companionbit, vous pouvez soit ajouter une @JvmStaticannotation, 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' @JvmStaticannotation 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 Companionnom, 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).

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.

A. Old Java Way:

1. Déclarez a companion objectpour inclure une méthode / variable statique

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

2. Utilisation :

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

B. Nouvelle voie Kotlin

1. Déclarez directement sur un fichier sans classe sur un .ktfichier.

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

2. Utilisez le methods/variablesavec leurs noms . ( Après les avoir importés )

   Utilisation :

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

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.

Cela a également fonctionné pour moi

object Bell {
    @JvmStatic
    fun ring() { }
}

de Kotlin

Bell.ring()

de Java

Bell.ring()

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!

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' staticinteropé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 staticfonctions / 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 objectclasses 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 INSTANCEobjet spécial est créé, qui est tout aussi encombrant à gérer qu'il l' Companionest. Voici comment utiliser des annotations pour lui donner une staticsensation de pureté en Java:

Scénario 4: utiliser des objectclasses

Kotlin

@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.

Première:

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)

Seconde:

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:JvmNameest 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

• L'ajout de compagnon à la déclaration d'objet permet d'ajouter la fonctionnalité statique à un objet même si le concept statique réel n'existe pas dans Kotlin.
• Un objet compagnon peut également accéder à tous les membres de la classe, y compris les constructeurs privés.
• Un objet compagnon est initialisé lorsque la classe est instanciée.

• 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

Tous les membres et fonctions statiques doivent être dans le bloc compagnon

  companion object {
    @JvmStatic
    fun main(args: Array<String>) {
    }

    fun staticMethod() {
    }
  }

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 SomeFuncfonction, 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()