«instanceof» en Kotlin: verificación de tipo con is y when (guía)

«instanceof» en Kotlin: por qué no es Java, y cómo hace el código más limpio

Si vienes a Kotlin desde el mundo de Java, seguramente estás acostumbrado a la palabra clave instanceof. Te ayuda a saber si un objeto es una instancia de una clase determinada. Pero en Kotlin este operador no existe. Y no es un error, es una característica.

Kotlin ofrece una forma mucho más elegante, segura y concisa de verificar el tipo de un objeto: el operador is. No solo responde a la pregunta «¿quién eres?», sino que también convierte automáticamente el objeto al tipo deseado. Esto se llama smart cast (conversión inteligente), y es una de esas características que hacen que el código en Kotlin sea tan agradable.

En esta guía, cubriremos:

\n
• Cómo usar el operador is en lugar de instanceof;
\n
• Qué es un smart cast y cómo funciona;
\n
• Cómo manejar elegantemente múltiples tipos con when;
\n
• En qué se diferencia la conversión segura as? de la conversión normal as;
\n
• Y, por supuesto, ejemplos de código reales.
\n

¡Allá vamos!

1. Operador is — el equivalente directo de instanceof

En Java escribirías:

if (obj instanceof String) {\n    String str = (String) obj;\n    System.out.println(str.length());\n}

En Kotlin, lo mismo se ve así:

if (obj is String) {\n    println(obj.length) // ¡Smart cast! obj ya es String\n}

Observa: después de la verificación obj is String, no necesitas convertir explícitamente obj al tipo String. El compilador de Kotlin sabe por sí mismo que dentro del bloque if, la variable obj está garantizada como una cadena. Esto es un smart cast (conversión inteligente).

¿Cómo funciona internamente?

El compilador analiza el flujo de ejecución. Si ve una verificación is y no encuentra la posibilidad de que el tipo de la variable cambie entre la verificación y el uso (por ejemplo, en código multiproceso o al modificar una var), convierte automáticamente el tipo. Para val esto siempre funciona, para var solo si la variable no puede modificarse entre la verificación y el uso.

2. Negación: !is

¿Quieres verificar que un objeto no es de un tipo? Usa !is:

if (obj !is String) {\n    println("Esto no es una cadena")\n} else {\n    // Aquí obj se convierte automáticamente a String\n    println("Longitud de la cadena: ${obj.length}")\n}

Práctico y legible, ¿verdad?

3. Verificaciones múltiples con when

Ahora imagina que tienes un objeto que puede ser uno de varios tipos. En Java escribirías una cadena de if-else if con instanceof. En Kotlin hay una herramienta más elegante: la construcción when.

fun describe(obj: Any): String {\n    return when (obj) {\n        is String -> "Cadena de longitud ${obj.length}"\n        is Int -> "Número entero: $obj"\n        is List<*> -> "Lista de ${obj.size} elementos"\n        is Map<*, *> -> "Mapa con ${obj.size} entradas"\n        else -> "Tipo desconocido"\n    }\n}\n\nfun main() {\n    println(describe("Hola"))   // Cadena de longitud 4\n    println(describe(42))         // Número entero: 42\n    println(describe(listOf(1,2)))// Lista de 2 elementos\n}

Observa: ¡dentro de cada rama de when también funciona el smart cast! En la rama is String, la variable obj ya se considera una cadena, y puedes llamar a obj.length sin necesidad de conversión adicional.

Esto es mucho más compacto y seguro que el clásico switch o una cadena de if.

4. Conversión segura: as?

A veces no solo necesitas verificar el tipo, sino obtener inmediatamente el valor de un tipo específico. En Java harías (String) obj