Todo sobre Kotlin Generics

1. Kotlin Generics
2. El problema de no usar Kotlin Generics
3. Cómo resuelven el problema Kotlin Generics
4. Pasar un Tipo de Método Genérico en Kotlin

Este artículo presenta el concepto de Kotlin Generics. Kotlin Generics son características poderosas que permiten definir clases y funciones accesibles a través de varios tipos de datos.

Kotlin Generics

Necesitamos declarar los genéricos como tipos parametrizados. Estos tipos parametrizados son una instancia de los tipos genéricos y se declaran mediante corchetes angulares <>.

Las diferencias de tipo de las clases genéricas y los métodos se comprueban en tiempo de compilación.

Aquí está la sintaxis:

Clases genéricas:

class_or_interface<Type>

Métodos genéricos:

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

Sabemos que Kotlin Generics son características poderosas, pero ¿qué las hace poderosas? Son las ventajas que ofrecen.

Ventajas de Kotlin Genéricos

Kotlin Generics brindan los siguientes beneficios clave.

1. Tipo de seguridad - Genérico permite mantener un solo tipo de objeto, eliminando las posibilidades de errores de tipo.
2. No es necesario encasillar: Genérico mitiga la necesidad de encasillar el objeto.
3. Comprobaciones en tiempo de compilación: las comprobaciones se realizan en tiempo de compilación para evitar errores en tiempo de ejecución.

El problema de no usar Kotlin Generics

El problema es que sin usar Kotlin Generics, no podemos pasar diferentes tipos de datos para un parámetro. Consideremos un ejemplo para ver esto.

Crearemos una clase Estudiante con un único parámetro. Luego pasaremos dos tipos de datos: Int y String, para ver qué sucede en el momento de la compilación.

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
}

Producción:

Como podemos ver en la salida, el programa arroja un error en tiempo de compilación. El código acepta el tipo Int tal como se inicializa pero rechaza el tipo String "19".

Cómo resuelven el problema Kotlin Generics

Para superar el problema con múltiples tipos de datos, podemos usar una clase genérica. Podemos superar el problema ya que la clase genérica acepta múltiples tipos de datos para un solo parámetro.

Aquí, crearemos una clase genérica que aceptará los tipos Int y 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
}

Producción:

En el ejemplo anterior, el tipo de datos de los objetos cambia según el parámetro que pasemos.

Pasar un Tipo de Método Genérico en Kotlin

Hemos visto cómo usar Kotlin Generics para pasar diferentes tipos de datos durante la inicialización. Pero, ¿y si queremos pasar un método genérico como parámetro?

Aquí hay un ejemplo donde creamos un método genérico y lo pasamos como parámetro.

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)
    }
}

Producción: