Docs recommande de résoudre la plupart des besoins pour les fonctions statiques avec fonctions de niveau paquet. Ils sont simplement déclarés en dehors d'une classe inn un fichier de code source. Le package d'un fichier peut être spécifié au début d'un package avec le mot-clé package.

Déclaration de

package foo

fun bar() = {}

L'Utilisation de

import foo.bar

Sinon

import foo.*

Vous pouvez maintenant appeler la fonction avec:

bar()

, Ou si vous n'utilisez pas l'importation mot-clé:

foo.bar()

Si vous ne spécifiez pas le package, la fonction sera accessible depuis la racine.

Si vous avez 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. Vous pourriez dire qu'il prend en charge les méthodes en dehors des classes.

1. Définir :

Tout method/ val/ var à l'intérieur de object( mot-clé pour Singleton) agira comme static en java.

Utilisez un companion object Si vous voulez appeler une méthode simplement en utilisant la classe qui contient l'objet.

object Foo{
fun sayFoo() = println("Foo")
val bar ="bar"
}

2. Utilisation :

Foo.sayFoo()
println(Foo.bar)

3. Sortie :

Foo
bar

Utiliser object pour représenter val/var/méthode pour faire de l'électricité statique. Vous pouvez également utiliser object au lieu de la classe singleton. Vous pouvez utiliser compagnon, si vous vouliez faire statique à l'intérieur d'une classe

object Abc{
     fun sum(a: Int, b: Int): Int = a + b
    }

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

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

Kotlin n'a aucun mot-clé statique. Vous avez utilisé cela pour java

 class AppHelper {
        public static int getAge() {
            return 30;
        }
    }

Et Pour Kotlin

class AppHelper {
        companion object {
            fun getAge() : Int = 30
        }
    }

Appel pour Java

AppHelper.getAge();

Appel pour 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 (en dehors de la classe). Mais il est préférable de définir des fonctions statiques dans la classe en utilisant 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 car vous appellerez n'importe quelle fonction à l'intérieur de L'objet compagnon.

object objectName {
    fun funName() {

    }
}

Vous devez simplement créer un objet compagnon et 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 import

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 l'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")
   }
}

Companion Objects est l'alternative du mot-clé java static et vous pouvez rendre une classe ou une méthode statique en les déclarant comme objets Companion.
Vous n'avez pas besoin de qualifier les objets compagnons avec le nom de classe si vous les appelez depuis la même classe.

Par exemple:

class SomeClass() {

    val id: Int

    init {
       id = nextId++       
    }

    private companion object {
       var nextId = 1
    }
}

fun main(args: Array<String>) {
    repeat(2) { 
        println(SomeClass().id)
    }
} 

Vous pouvez utiliser des objets autres que l'objet compagnon

object Utils {
    fun someFunction()
}

Donc, cela ressemblera quand la méthode est appelée.

Utils.someFunction()

Créez un objet compagnon et marquez la méthode avec l'annotation jvmstatic

Cela a également fonctionné pour moi

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

De Kotlin

Bell.ring()

De Java

Bell.ring()

Il y a 2 façons d'appliquer la statique dans Kotlin

Créez D'abord un objet compagnon sous la classe

Pour ex:

class Test{
    companion object{
          fun isCheck(a:Int):Boolean{
             if(a==0) true else false
          }
     }
}

Vous pouvez appeler cette fonction comme

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
       }
}

Bon Codage!

Écrivez-les directement dans des fichiers.

En Java (laid):

package xxx;
class XxxUtils {
  public static final Yyy xxx(Xxx xxx) { return xxx.xxx(); }
}

Dans Kotlin:

@file:JvmName("XxxUtils")
package xxx
fun xxx(xxx: Xxx): Yyy = xxx.xxx()

Ces deux codes sont égaux après la compilation (même le nom du fichier compilé, le file:JvmName est utilisé pour contrôler le nom du fichier compilé, qui doit être placé juste avant la déclaration du nom du paquet).

Utilisez la fonction dans "objet compagnon ou objet nommé".

Voir exemple d'objet compagnon:

   class Foo {
  companion object {
     fun square(x : Int) : Int = x*x
  }
}

Voir l'exemple d'objet nommé

object Foo{
   fun square(x : Int) : Int = x*x
}

Vous pouvez y accéder en utilisant

val k = Foo.square(12)

Si vous suivez le style d'écriture de la statique en haut de la classe en Java, alors je suggère d'essayer d'envisager de les écrire au niveau supérieur (par exemple avant la déclaration de classe) dans Kotlin. Pour de nombreux cas d'utilisation, cela fonctionne mieux que d'introduire un objet compagnon

Exemple De Code:

class Person {
companion object Test {
    fun callMe() = println("I'm called.")
}


}

fun main(args: Array<String>) { Person.callMe()}

Lorsque vous exécutez le programme, la sortie sera:

On m'appelle.

Supposons que vous avez une classe Étudiant. Et vous avez une méthode statique getUniversityName() & un champ appelé totalStudent.

Vous devez déclarer un bloc d'objets compagnon dans votre classe.

    companion object {
 // define static method & field here.
}

Alors 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 statiques et ces champs comme ceci.

println("University : " + Student.getUniversityName() + ", Total Student: " + Student.totalStudent)
    // Output:
    // University : MBSTU, Total Student: 30

Vous pouvez obtenir la fonctionnalité statique dans Kotlin par objets compagnons

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

• Un objetcompagnon 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 la classe comme qualificatif:

Sortie:

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 statiques et la fonction doivent être à l'intérieur du bloc compagnon

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

    fun staticMethod() {
    }
  }

Le code java est comme ci-dessous:

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

Deviendra comme ci-dessous dans kotlin:

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

Cependant, en utilisant l'annotation @ JvmStatic sur la JVM, nous pouvons avoir des membres d'objets compagnons générés en tant que Méthodes et champs statiques réels.

Utiliser L'Annotation statique JVM

Objet compagnon {

    // 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)
                }
            }
}

Dans la méthode statique java

public static add(){

}

Dans la méthode statique kotlin

fun add():??? {
}