Obtenir l'instance d'un objet dans Kotlin

1. Utilisez is avec des génériques pour obtenir l’instance d’un objet dans Kotlin
2. Utilisez is avec le mot-clé quand pour obtenir l’instance d’un objet dans Kotlin
3. Conclusion

Obtenir l’instance d’un objet est une pratique de développement courante que nous rencontrerons dans la plupart des langages de programmation tels que Kotlin, Java, TypeScript, JavaSript et autres. Un exemple d’une situation où vous pourriez vouloir trouver l’instance d’un élément est lorsque vous voulez trier des éléments en fonction de leur type.

Lors de la recherche de l’instance d’un élément, le résultat est vrai si l’élément a le même type que l’élément mis en correspondance ; sinon, il renvoie faux.

Dans ce didacticiel, nous allons apprendre à obtenir l’instance d’un objet lors de l’exécution à l’aide de Kotlin.

Utilisez is avec des génériques pour obtenir l’instance d’un objet dans Kotlin

Le générique est une approche de développement utilisée pour concevoir notre code afin qu’il puisse être réutilisé en utilisant n’importe quel type.

Allez dans IntelliJ et sélectionnez File > New Project pour créer un nouveau projet Kotlin. Entrez le nom du projet comme kotlinInstancOf ou tout autre nom que vous préférez.

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.

Une fois le projet créé, créez la structure de dossiers com/instanceOf sous le dossier kotlin. Créez un fichier nommé Main.kt dans le dossier instanceOf, puis copiez et collez le code suivant dans le fichier :

package com.instanceOf

interface Employee{
    fun work(): String;
}
class Manager(private val name: String): Employee{
    override fun work(): String {
        return "$name is preparing the project schedule";
    }

}
class Janitor(private val name: String): Employee{
    override fun work(): String {
        return "$name is cleaning the office";
    }

}
fun <T> doWork(Object: T): String {
    if (Object is Employee){
       return Object.work();
    }else{
        throw RuntimeException("$Object is not of type Employee")
    }
}

fun main() {
    println(doWork(Manager("John")));
    println(doWork(Janitor("Peter")));
    println(doWork("mary"));
}

Dans cet exemple, nous avons créé une interface nommée Employee et deux implémentations concrètes nommées Manager et Janitor.

Le doWork() est une méthode générique définie ci-dessus, qui utilise le mot clé is pour savoir si l’objet passé en argument est du même type que Employee. Si la condition retourne true, on invoque la méthode work() de l’objet ; sinon, on lance une RuntimeException().

Dans la méthode principale, nous appelons la méthode doWork() 3 fois et passons respectivement le Manager, le Janitor et une chaîne comme arguments.

Les deux premières invocations de la méthode sont évaluées comme vraies car elles ont une relation avec le Employee. Mais la dernière invocation est évaluée comme fausse parce que l’argument chaîne n’a pas de relation avec le Employee.

Exécutez le code pour vérifier que la sortie est comme indiqué ci-dessous.

Exception in thread "main" java.lang.RuntimeException: mary is not of type Employee
John is preparing the project schedule
Peter is cleaning the office

Puisque le mot-clé is renvoie un booléen, nous pouvons retourner l’inverse du mot-clé is en ajoutant le caractère ! avant le mot clé. Le personnage ! est généralement prononcé comme not, ce qui est courant lorsque l’on travaille avec des portes logiques.

Commentez la méthode doWork() et remplacez-la par le code suivant :

fun <T> doWork(Object: T): String{
    if (Object !is Employee){
        throw RuntimeException("$Object is not of type employee");
    }
    return Object.work();
}

Réexécutez le code et notez que le résultat est identique à la sortie de l’exemple précédent :

John is preparing the project schedule
Peter is cleaning the office
Exception in thread "main" java.lang.RuntimeException: mary is not of type employee

Utilisez is avec le mot-clé quand pour obtenir l’instance d’un objet dans Kotlin

Le mot-clé when fonctionne de la même manière que le mot-clé switch fonctionne avec Java. La seule différence est la syntaxe.

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

fun fetchData() = listOf<Any>("book",3,true,"computer");

fun main() {
    for (data in fetchData()) {
        when(data){
            is String -> println(data)
            is Int -> println(data)
            is Boolean -> println(data)
        }
    }
}

Dans l’exemple ci-dessus, nous avons créé une méthode fetchData() qui renvoie une liste de type Any en l’affectant à la méthode d’assistance listOf(). La méthode listOf() renvoie une liste contenant les types String, Int et Boolean.

Dans la méthode main, nous avons déterminé le type d’élément à l’exécution en parcourant la liste à l’aide d’une boucle et en déléguant chaque valeur à la méthode when(). À l’intérieur du bloc when(), le type de la valeur transmise est déterminé à l’aide de is, et si la condition est vraie, la valeur est enregistrée dans la console.

Vous devez noter que la valeur ne sera pas enregistrée dans la console si vous ajoutez un autre type dans la liste sans trouver son type dans le bloc when().

Exécutez le code et vérifiez que le résultat est comme indiqué ci-dessous :

book
3
true
computer

Conclusion

Dans ce didacticiel, nous avons appris à obtenir l’instance d’un élément lors de l’exécution en utilisant le langage de programmation Kotlin. Les approches couvertes incluent : l’utilisation du mot-clé is avec des génériques et du mot-clé is avec le mot-clé when.

Notez que lors de l’utilisation de génériques, nous devons nous assurer que nous utilisons des types réifiés, ce qui signifie que les informations de type sont disponibles au moment de l’exécution ; sinon, la vérification de type ne fonctionnera pas.