Tout sur les génériques de Kotlin

1. Génériques Kotlin
2. Le problème de ne pas utiliser les génériques Kotlin
3. Comment les génériques de Kotlin résolvent le problème
4. Passer un type de méthode générique dans Kotlin

Cet article présente le concept de génériques Kotlin. Les génériques Kotlin sont des fonctionnalités puissantes qui permettent de définir des classes et des fonctions accessibles via différents types de données.

Génériques Kotlin

Nous devons déclarer les génériques en tant que types paramétrés. Ces types paramétrés sont une instance de types génériques et sont déclarés à l’aide de chevrons <>.

Les différences de type entre les classes génériques et les méthodes sont vérifiées au moment de la compilation.

Voici la syntaxe :

Classes génériques :

class_or_interface<Type>

Méthodes génériques :

<Type>methodName(parameter: classType<Type>)

Nous savons que les génériques de Kotlin sont des fonctionnalités puissantes, mais qu’est-ce qui les rend puissants ? Ce sont les avantages qu’ils offrent.

Avantages des génériques Kotlin

Les génériques de Kotlin offrent les avantages clés suivants.

1. Sécurité de type - Generic permet de ne contenir qu’un seul type d’objet, éliminant ainsi les risques d’erreurs de type.
2. Pas besoin de transtypage - Generic atténue le besoin de transtypage de l’objet.
3. Vérifications au moment de la compilation - Les vérifications sont effectuées au moment de la compilation pour éviter les erreurs d’exécution.

Le problème de ne pas utiliser les génériques Kotlin

Le problème est que sans utiliser les génériques Kotlin, nous ne pouvons pas transmettre différents types de données pour un paramètre. Prenons un exemple pour le voir.

Nous allons créer une classe Student avec un seul paramètre. Nous passerons ensuite deux types de données : Int et String, pour voir ce qui se passe au moment de la compilation.

class Student (id:Int){
    var id: Int = id
    init {
        this.id = id
        println(id)
    }
}

fun main(args: Array<String>){
    var idInt: Student = Student(17)
    var idString: Student = Student("19") // This throws an error
}

Production:

Comme nous pouvons le voir dans la sortie, le programme génère une erreur de compilation. Le code accepte le type Int tel qu’il est initialisé mais rejette le type String "19".

Comment les génériques de Kotlin résolvent le problème

Pour surmonter le problème avec plusieurs types de données, nous pouvons utiliser une classe générique. Nous pouvons surmonter le problème puisque la classe générique accepte plusieurs types de données pour un seul paramètre.

Ici, nous allons créer une classe générique qui acceptera à la fois les types Int et String.

class Student<T>(id: T){
    var id: T = id
    init {
        this.id = id
        println(id)
    }
}

fun main(args: Array<String>){
    var idInt: Student<Int> = Student(17)
    var idString: Student<String> = Student("19") // This won't throw an error
}

Production:

Dans l’exemple ci-dessus, le type de données des objets change en fonction du paramètre que nous passons.

Passer un type de méthode générique dans Kotlin

Nous avons vu comment utiliser les génériques Kotlin pour transmettre différents types de données lors de l’initialisation. Mais que se passe-t-il si nous voulons passer une méthode générique en paramètre ?

Voici un exemple où nous créons une méthode générique et la passons en paramètre.

import kotlin.reflect.KClass

data class Person(val city: String)
data class Employee(val city: String)

fun getPerson(): List<Person> = listOf(Person("New York"))
fun getEmployee(): List<Employee> = listOf(Employee("Chicago"))

fun <T: Any> getInfo(xyz: KClass<T>): List<T>? {
    return when(xyz) {
        Person::class -> getPerson() as List<T>
        Employee::class -> getEmployee()  as List<T>
        else -> null
    }
}

fun main(args: Array<String>) {
    val v = listOf(Person::class, Employee::class)
    v.forEach { type ->
        val i = getInfo(type)
        println(i)
    }
}

Production: