Les constantes de Kotlin — ce qui est une méthode recommandée pour les créer?

Dans Kotlin, si vous souhaitez créer les constantes locales qui sont censés être utilisés dans la classe puis vous pouvez le créer comme ci-dessous

val MY_CONSTANT = "Constants"

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

companion object{

     const val MY_CONSTANT = "Constants"

}

Des valeurs connues au moment de la compilation peut (et à mon avis devrait) être marqué comme constante.

Conventions de nommage doit suivre Java et doit être bien visible lorsque utilisé à partir du code Java (c'est un peu dur à atteindre avec le compagnon des objets, mais de toute façon).

Le bon déclarations de constantes sont:

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

Tout d'abord, la convention de nommage dans Kotlin pour les constantes est le même qu'en java (e.g : MY_CONST_IN_UPPERCASE).

Comment dois-je le créer ?

1. Un haut niveau de valeur (recommandée)

Vous avez juste à mettre votre const à l'extérieur votre déclaration de classe.

Deux possibilités : Déclarer votre const dans votre fichier de classe (votre const ont une relation évidente avec votre classe)

private const val CONST_USED_BY_MY_CLASS = 1

class MyClass { 
    //I can use my const in my class body 
}

Créer un dédié constantes.kt fichier où stocker ces constantes globales (Ici vous souhaitez utiliser votre const largement l'ensemble de votre projet) :

package com.project.constants
const val URL_PATH = "https:/"

Ensuite vous avez juste à importer où vous en avez besoin :

import com.project.constants

MyClass {
    private fun foo() {
        val url = URL_PATH
        System.out.print(url) //https://
    }
}

2. Il déclare dans un compagnon de l'objet (ou d'un objet de la déclaration)

C'est beaucoup moins plus propre, car sous le capot, lorsque le bytecode généré, inutile de l'objet est créée :

MyClass {
    companion object {
        private const val URL_PATH = "https://"
        const val PUBLIC_URL_PATH = "https://public" //Accessible in other project files via MyClass.PUBLIC_URL_PATH
    }
}

Encore pire si vous le déclare comme val, au lieu de const (compilateur va générer un inutile d'objet + une fonction inutile) :

MyClass {
    companion object {
        val URL_PATH = "https://"
    }
}

Remarque :

Dans kotlin, const suffit de les tenir types primitifs. Si vous voulez passer une fonction, vous devez ajouter l' @JvmField annotation. Au moment de la compilation, il se transformera en tant que public static final variable. Mais c'est plus lent qu'avec un type primitif. Essayez de l'éviter.

@JvmField val foo = Foo()

class Myclass {

 companion object {
        const val MYCONSTANT = 479
}

vous avez deux choix, vous pouvez utiliser const mot-clé ou utiliser le @JvmField qui en fait une java static final constante.

class Myclass {

     companion object {
           @JvmField val MYCONSTANT = 479
    }

Si vous utilisez le @JvmField annotation puis, après, il compile la constante est mis en pour vous la façon dont vous voulez l'appeler, dans java.

Comme vous l'appeler en java, le compilateur remplace que pour vous lorsque vous appelez le compagnon constant dans le code.

Toutefois, si vous utilisez le mot-clé const alors la valeur de la constante obtient inline. Par inline je veux dire la valeur réelle est utilisée après qu'il compile.

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

//so for @JvmField:

Foo var1 = Constants.FOO;

//and for const:

Foo var1 = 479

constantes locales:

const val NAME = "name"

Constantes globales:

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

accès MyConstants.NOM

Il existe quelques façons dont vous pouvez définir des constantes dans Kotlin,

À l'aide de compagnon objet

    companion object {
        const val ITEM1 = "item1"
        const val ITEM2 = "item2"
    }

vous pouvez utiliser au-dessus de compagnon objet de bloc à l'intérieur de toute classe et de définir tous les champs à l'intérieur de ce bloc lui-même. Mais il y a un problème avec cette approche, la documentation dit,

même si les membres de compagnon objets ressemblent à des membres statiques dans d'autres langues, à l'exécution, ceux qui sont encore membres de l'instance de l'objet réel, et peuvent, par exemple, de mettre en œuvre des interfaces.

Lorsque vous créez votre constantes à l'aide de compagnon de l'objet, et de voir le décompilé bytecode, vous aurez quelque chose comme ci-dessous,

  ClassName.Companion Companion = ClassName.Companion.$$INSTANCE;
  @NotNull
  String ITEM1 = "item1";
  @NotNull
  String ITEM2 = "item2";

  public static final class Companion {
     @NotNull
     private static final String ITEM1 = "item1";
     @NotNull
     public static final String ITEM2 = "item2";

     //$FF: synthetic field
     static final ClassName.Companion $$INSTANCE;

     private Companion() {
     }

     static {
        ClassName.Companion var0 = new ClassName.Companion();
        $$INSTANCE = var0;
     }
  }

À partir d'ici vous pouvez facilement voir ce que la documentation dit, , même si les membres de compagnon objets ressemblent à des membres statiques dans d'autres langues, à l'exécution, ceux qui sont encore membres de l'instance de l'objet réel C'est de faire du travail supplémentaire que nécessaire.

Maintenant vient une autre façon, où nous n'avons pas besoin d'utiliser compagnon objet comme ci-dessous,

object ApiConstants {
      val ITEM1: String = "item1"
 }

De nouveau si vous voyez le décompilé version de l'octet code de l'extrait ci-dessus, vous trouverez quelque chose comme cela,

public final class ApiConstants {
     private static final String ITEM1 = "item1";

     public static final ApiConstants INSTANCE;

     public final String getITEM1() {
           return ITEM1;
      }

     private ApiConstants() {
      }

     static {
         ApiConstants var0 = new ApiConstants();
         INSTANCE = var0;
         CONNECT_TIMEOUT = "item1";
      }
    }

Maintenant, si vous voyez ci-dessus le code decompile, c'est la création de la méthode get pour chaque variable. Cette méthode get n'est pas nécessaire à tous.

Pour se débarrasser de ces méthodes get, vous devez utiliser const avant val comme ci-dessous,

object ApiConstants {
     const val ITEM1: String = "item1"
 }

Maintenant, si vous voyez le code décompilé de l'extrait ci-dessus, vous le trouverez plus facile à lire car il fait le moins de conversion en arrière-plan pour votre code.

public final class ApiConstants {
    public static final String ITEM1 = "item1";
    public static final ApiConstants INSTANCE;

    private ApiConstants() {
     }

    static {
        ApiConstants var0 = new ApiConstants();
        INSTANCE = var0;
      }
    }

Donc, c'est le meilleur moyen de créer des constantes.