Manejo de errores en Kotlin: try/catch, null safety y clases sealed

Manejo de errores en Kotlin: try/catch y más

El manejo de errores es una de las tareas clave al escribir código robusto y confiable. Kotlin, como lenguaje de programación moderno, ofrece a los desarrolladores varias herramientas potentes para trabajar con excepciones y situaciones anómalas. En este artículo, analizaremos en detalle el mecanismo clásico try/catch, las características de null safety, así como enfoques avanzados: el uso de Result y sealed classes. El material será útil tanto para principiantes como para programadores experimentados que deseen estructurar sus conocimientos.

1. try/catch clásico en Kotlin

Kotlin es completamente compatible con Java y admite el bloque tradicional try/catch/finally. Sin embargo, hay diferencias importantes: en Kotlin, las excepciones son unchecked (no verificadas), es decir, el compilador no te obliga a manejarlas. Esto hace que el código sea más conciso, pero requiere atención.

La sintaxis es la siguiente:

try {    // Código que puede lanzar una excepción    val result = riskyOperation()    println("Resultado: $result")} catch (e: Exception) {    // Manejo de la excepción    println("Ocurrió un error: ${e.message}")} finally {    // El bloque se ejecuta en cualquier caso    println("Finalizando operación")}

En Kotlin, try puede usarse como una expresión que devuelve un valor:

val number: Int? = try {    "123".toInt()} catch (e: NumberFormatException) {    null}println(number) // Imprimirá: 123

Esto es especialmente útil cuando se necesita obtener un resultado o un valor por defecto sin variables adicionales.

2. Null Safety: prevención de errores a nivel de tipos

Una de las principales características de Kotlin es null safety. El lenguaje resuelve el problema de NullPointerException en tiempo de compilación. Los tipos en Kotlin se dividen en nullable (pueden ser null) y non-null (no pueden).

Ejemplo:

var name: String = "Kotlin"  // No puede ser null// name = null // ¡Error de compilación!

var nullableName: String? = "Kotlin" // Puede ser nullnullableName = null // Funciona

Para trabajar de forma segura con tipos nullable, Kotlin ofrece varios operadores:

• ?. (safe call) — ejecuta la operación solo si el valor no es null:

val length = nullableName?.length // Si es null, entonces null




• ?: (elvis operator) — devuelve un valor por defecto si el objeto es null:

val length = nullableName?.length ?: 0




• !! (not-null assertion) — afirma que el valor no es null (úsese con precaución):

val length = nullableName!!.length // Si es null — excepción

El uso de null safety en lugar de try/catch para verificaciones de null hace que el código sea más legible y seguro.

3. Uso de Result para un enfoque funcional

Kotlin proporciona la clase incorporada Result<T>, que representa el resultado de una operación que puede completarse con éxito o con error. Esta es una alternativa a try/catch basada en la programación funcional.

Ejemplo de uso:

fun riskyDivision(a: Int, b: Int): Result<Int> {    return runCatching {        a / b    }}

fun main() {    val result = riskyDivision(10, 0)

    result.onSuccess { value ->        println("Éxito: $value")    }.onFailure { error ->        println("Error: ${error.message}")    }

    // O se puede obtener el valor con un valor por defecto    val value = result.getOrDefault(0)    println("Valor: $value")}

runCatching es una función envolvente conveniente que captura cualquier excepción y devuelve un Result. Puedes combinar Result con cadenas de llamadas, lo que