Constantes dans Kotlin – comment les créer?

Comment est-il recommandé de créer des constantes dans Kotlin? Et quelle est la convention de nommage? Je n’ai pas trouvé cela dans la documentation.

companion object { //1 val MY_CONST = "something" //2 const val MY_CONST = "something" //3 val myConst = "something" } 

Ou …?

Dans Kotlin, si vous voulez créer les constantes locales qui doivent être utilisées avec dans la classe, vous pouvez les créer comme ci-dessous

 val MY_CONSTANT = "Constants" 

Et si vous voulez créer une constante publique dans kotlin comme final statique public dans java, vous pouvez le créer comme suit.

 companion object{ const val MY_CONSTANT = "Constants" } 

Les valeurs connues au moment de la compilation peuvent (et à mon avis devraient) être marquées comme étant constantes.

Les conventions de dénomination doivent suivre celles de Java et doivent être correctement visibles lorsqu’elles sont utilisées à partir du code Java (c’est difficile à réaliser avec les objects compagnons, mais de toute façon).

Les constantes déclarations sont:

 const val MY_CONST = "something" const val MY_INT = 1 

Évitez d’utiliser des objects compagnons. Derrière la méthode getter et setter de hood est créée pour que les champs soient accessibles et les méthodes d’instance d’appel sont techniquement plus coûteuses que l’appel de méthodes statiques.

 public class DbConstants { companion object { val TABLE_USER_ATTRIBUTE_EMPID = "_id" val TABLE_USER_ATTRIBUTE_DATA = "data" } 

Définissez plutôt les constantes dans object .

Pratique recommandée :

 object DbConstants { const val TABLE_USER_ATTRIBUTE_EMPID = "_id" const val TABLE_USER_ATTRIBUTE_DATA = "data" } 

et y accéder globalement comme ceci: DbConstants.TABLE_USER_ATTRIBUTE_EMPID

Vous n’avez pas besoin d’une classe, d’un object ou d’un object compagnon pour déclarer des constantes dans Kotlin. Vous pouvez simplement déclarer un fichier contenant toutes les constantes (par exemple, Constants.kt ) et déclarer directement les constantes dans le fichier. Les constantes connues à la compilation doivent être marquées avec const .

Donc, dans ce cas, il devrait être:

const val MY_CONST = "something"

et puis vous pouvez importer la constante en utilisant:

import package_name.MY_CONST

Vous pouvez vous référer à ce lien

 class Myclass { companion object { const val MYCONSTANT = 479 } 

Vous avez le choix entre deux mots-clés const ou utiliser @JvmField, ce qui en fait une constante finale Java statique.

 class Myclass { companion object { @JvmField val MYCONSTANT = 479 } 

Si vous utilisez l’annotation @JvmField, une fois compilée, la constante est mise pour vous comme vous l’appelez en Java.
Tout comme vous l’appelleriez en Java, le compilateur le remplacera lorsque vous appelez le compagnon constant dans le code.

Toutefois, si vous utilisez le mot-clé const, la valeur de la constante devient intégrée. Par inline, je veux dire que la valeur réelle est utilisée après la compilation.

pour résumer, voici ce que le compilateur fera pour vous:

 //so for @JvmField: Foo var1 = Constants.FOO; //and for const: Foo var1 = 479 

Quelque chose qui n’est mentionné dans aucune des réponses est la surcharge de l’utilisation d’ companion objects . Comme vous pouvez le lire ici , les objects compagnons sont en fait des objects et leur création consum des ressources. De plus, vous devrez peut-être passer par plus d’une fonction de lecture chaque fois que vous utilisez votre constante. Si vous n’avez besoin que de quelques constantes primitives, vous ferez probablement mieux d’utiliser val pour obtenir de meilleures performances et éviter l’ companion object .

TL; DR; de l’article:

L’utilisation d’un object compagnon transforme en réalité ce code

 class MyClass { companion object { private val TAG = "TAG" } fun helloWorld() { println(TAG) } } 

Dans ce code:

 public final class MyClass { private static final Ssortingng TAG = "TAG"; public static final Companion companion = new Companion(); // synthetic public static final Ssortingng access$getTAG$cp() { return TAG; } public static final class Companion { private final Ssortingng getTAG() { return MyClass.access$getTAG$cp(); } // synthetic public static final Ssortingng access$getTAG$p(Companion c) { return c.getTAG(); } } public final void helloWorld() { System.out.println(Companion.access$getTAG$p(companion)); } } 

Alors, essayez de les éviter.

constantes locales:

 const val NAME = "name" 

Constantes globales:

 object MyConstants{ val NAME = "name" val ID = "_id" var EMAIL = "email" } 

accéder à MyConstants.NAME

Si vous mettez votre “const val valName = valValue” avant le nom de la classe, cela créera un “public static final YourClassKt” qui aura les valeurs “public static final”.

Kotlin:

 const val MY_CONST0 = 0 const val MY_CONST1 = 1 data class MyClass(var some: Ssortingng) 

Java décompilé:

 public final class MyClassKt { public static final int MY_CONST0 = 0; public static final int MY_CONST1 = 1; } // rest of MyClass.java 

Vérifiez cet article . Il donne un bon aperçu des différentes manières dont vous pouvez stocker vos constantes, avec des compromis de performance connexes.