Créer des constantes dans Kotlin

1. Utiliser les constantes de classe dans Kotlin
2. Utiliser un singleton dans Kotlin
3. Utiliser des constantes de niveau supérieur dans Kotlin
4. Utiliser un fichier séparé contenant des constantes dans Kotlin
5. Conclusion

Une constante est utilisée pour stocker des données dont les valeurs sont toujours connues et les données ne changent pas pendant l’exécution du programme. Les constantes se différencient des variables en ce que les variables peuvent modifier les données pendant l’exécution du programme.

Par exemple, disons que vous développez un simulateur de moto. Différentes propriétés de la moto ne changeront jamais pendant toute sa durée de vie, comme le nombre de roues.

Pour s’assurer que le nombre de roues ne change pas, nous déclarons une constante dans l’application et l’affectons au nombre de roues qu’une moto peut avoir. Nous utilisons des constantes pour éviter les erreurs d’entrée de l’utilisateur, comme fournir quatre roues pour une moto au lieu de deux.

Dans ce didacticiel, nous apprendrons comment créer des constantes dans Kotlin, la convention de nommage utilisée et comment les inclure dans votre application.

Utiliser les constantes de classe dans Kotlin

Allez dans IntelliJ et sélectionnez File > New > Project pour créer un nouveau projet Kotlin. Entrez kotlinConstants comme nom de projet ou tout nom préféré.

Sélectionnez Kotlin dans la section Langue et Intellij dans la section Build System. Appuyez sur le bouton Créer pour créer le projet.

Créez la structure de dossiers com/constants sous le dossier kotlin. Créez un fichier Main.kt dans le dossier constants, puis copiez et collez le code suivant dans le fichier.

package com.constants

class Car(private val name: String){
    /**
     * This is a constant that is only used
     * inside this class
     */
    private val numberOfWheels = 4
    /**
     * The companion object defines a constant
     * that exists only as a single copy and
     * Can also be used outside the class
     */
    companion object{
        const val NUMBER_OF_WHEELS = 4
    }
    fun showMessage(): String{
        return "A ${this.name} has ${this.numberOfWheels} wheels"
    }

}
fun main() {
    val nissan = Car("Nissan");
    println(nissan.showMessage());
    println("Number of wheels = ${Car.NUMBER_OF_WHEELS}");
}

Nous avons déclaré deux constantes dans la classe Car ; la première constante déclarée à l’aide du mot-clé private n’est destinée à être utilisée que dans cette classe et n’est pas accessible depuis l’extérieur de la classe.

En ce qui concerne la convention de nommage, nous avons utilisé la convention de nommage en cas de chameau car elle n’est utilisée qu’à l’intérieur de la classe.

La seconde constante est déclarée dans un objet compagnon de la classe. Un objet compagnon est utilisé pour déclarer des constantes et des fonctions appartenant à cette classe, ce qui signifie qu’il ne peut pas être instancié à l’aide des objets de classe.

Ces constantes sont similaires aux champs et méthodes statiques de Java. Pour invoquer les constantes, nous utilisons généralement la classe car il n’existe qu’une seule copie des constantes.

Les constantes déclarées à l’intérieur d’un objet compagnon sont accessibles depuis l’extérieur de la classe, et la convention de dénomination utilisée pour ces constantes est une combinaison de lettres majuscules et de traits de soulignement.

La méthode main invoque Car() pour créer un nouvel objet Car. La méthode showMessage() utilise la constante utilisée dans la classe pour enregistrer un message contenant la valeur dans la console.

Le dernier message println() enregistre la valeur de la constante déclarée à l’aide d’un objet compagnon. Exécutez le code pour vérifier que le programme génère les éléments suivants.

Production:

A Nissan has 4 wheels
Number of wheels = 4

Utiliser un singleton dans Kotlin

Singleton est un modèle de conception en programmation, en particulier dans les langages de haut niveau. Le modèle de conception singleton est utilisé lorsque nous avons des ressources qui doivent être partagées dans l’application et dans des situations où il est coûteux de créer les ressources.

Notez que lorsque vous utilisez un singleton, une seule instance sera créée pendant toute la durée de vie de l’application.

Commentez le code précédent et copiez-collez le code suivant dans le fichier Main.kt après le commentaire.

package com.constants

object Configuration{
    const val USERNAME = "john"
    const val PASSWORD = "1234"
}

fun userLogin(user: String, pass: String): String{
    return "$user logged in with password $pass"
}

fun main() {
    println(userLogin(Configuration.USERNAME,
        Configuration.PASSWORD));
}

Dans cet exemple, nous avons créé un singleton en utilisant le mot-clé object. Utilisez toujours cette syntaxe lorsque vous souhaitez créer un singleton dans Kotlin.

En coulisses, le compilateur rend le constructeur privé, crée une référence de notre Configuration, et l’initialise dans un bloc statique. Le singleton ne sera initialisé qu’une fois que nous aurons accédé pour la première fois aux champs statiques.

Le userLogin() est une méthode personnalisée que nous avons définie pour consommer les propriétés du singleton. Pour accéder aux valeurs, nous invoquons le nom du singleton suivi du nom de la propriété.

Ceci est similaire à ce que nous avons fait avec des constantes déclarées dans un objet compagnon, mais cette approche est moins gourmande en ressources. Exécutez le code et vérifiez que le programme affiche les éléments suivants.

Production:

john logged in with password 1234

Utiliser des constantes de niveau supérieur dans Kotlin

Commentez le code précédent, puis copiez et collez le code suivant dans le fichier Main.kt après le commentaire.

package com.constants

const val CONNECTION_POOL = 10

class DBDriver{
   companion object{
       fun isConnectionExceeded(value: Int): Boolean{
           return (value > CONNECTION_POOL)
       }
   }
}

fun main() {
    println(DBDriver.isConnectionExceeded(11));
}

Les constantes de niveau supérieur ne sont pas incluses dans une fonction, une classe ou une interface, ce qui signifie que vous pouvez les appeler depuis l’extérieur de la classe sans créer d’objet.

Dans cet exemple, nous avons déclaré une constante de niveau supérieur nommée CONNECTION_POOL et l’avons consommée dans la méthode isConnectionExceeded() en passant son nom.

Exécutez le code et notez que la valeur constante est lue comme d’habitude pour effectuer les calculs attendus, comme indiqué ci-dessous.

Production:

true

Utiliser un fichier séparé contenant des constantes dans Kotlin

Créez un nouveau package nommé consts dans le dossier com. Créez un fichier nommé NetConstants.kt dans le dossier consts, puis copiez et collez le code suivant dans le fichier.

package com.consts

const val PORT = 8080
const val PROTOCOL = "DNS"
const val HOST_ADDRESS = "192.168.1.0"

Les constantes définies dans le fichier ci-dessus sont similaires aux constantes de niveau supérieur mais sont déclarées dans un fichier séparé avec d’autres parties de l’application.

L’exemple suivant montre l’utilisation de constantes dans un fichier séparé de la même application. Commentez le dernier exemple que nous avons couvert dans le fichier Main.kt, et copiez et collez le code suivant dans le fichier après le commentaire.

package com.constants

import com.consts.HOST_ADDRESS
import com.consts.PORT
import com.consts.PROTOCOL

class Server{
   companion object{
       fun connectServer(port: Int, protocol: String, host: String): String{
           return "application connected to " +
                   "$host using port " +
                   "$port through" +
                   " $protocol"
       }
   }
}
fun main() {
    println(Server.connectServer(PORT, PROTOCOL, HOST_ADDRESS));
}

Cet exemple définit la méthode connectServer() déclarée à l’intérieur d’un objet compagnon d’une classe. La méthode consomme les trois constantes que nous avons définies dans le fichier NetConstants.kt.

Ceci est réalisé en passant le nom de la constante à la méthode et en important le nom complet de la constante dans la classe. Voici la sortie de l’application après son exécution :

application connected to 192.168.1.0 using port 8080 through DNS

Conclusion

Dans ce didacticiel, nous avons appris les différentes manières de créer des constantes dans une application Kotlin. Les approches que nous avons apprises incluent : l’utilisation de constantes de classe, de singletons et de constantes de niveau supérieur, et enfin, nous avons expliqué comment utiliser des constantes déclarées dans un fichier séparé.