Tratamento de erros em Kotlin: try/catch, null safety e classes sealed

Tratamento de Erros em Kotlin: try/catch e Além

O tratamento de erros é uma das tarefas principais ao escrever código confiável e robusto. Kotlin, como uma linguagem de programação moderna, oferece aos desenvolvedores várias ferramentas poderosas para trabalhar com exceções e situações anormais. Neste artigo, vamos detalhar o mecanismo clássico try/catch, os recursos de null safety, bem como abordagens avançadas: o uso de Result e sealed classes. O material será útil tanto para iniciantes quanto para programadores experientes que desejam estruturar seus conhecimentos.

1. try/catch Clássico em Kotlin

Kotlin é totalmente compatível com Java e suporta o bloco tradicional try/catch/finally. No entanto, existem diferenças importantes: em Kotlin, as exceções são unchecked (não verificadas), ou seja, o compilador não obriga você a tratá-las. Isso torna o código mais conciso, mas exige atenção.

A sintaxe é a seguinte:

try {    // Código que pode lançar uma exceção    val result = riskyOperation()    println("Resultado: $result")} catch (e: Exception) {    // Tratamento da exceção    println("Ocorreu um erro: ${e.message}")} finally {    // Bloco executado em qualquer caso    println("Finalizando operação")}

Em Kotlin, try pode ser usado como uma expressão que retorna um valor:

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

Isso é especialmente útil quando você precisa obter um resultado ou um valor padrão sem variáveis extras.

2. Null Safety: Prevenindo Erros no Nível dos Tipos

Uma das principais funcionalidades do Kotlin é a null safety. A linguagem resolve o problema do NullPointerException em tempo de compilação. Os tipos em Kotlin são divididos em nullable (podem ser null) e non-null (não podem).

Exemplo:

var name: String = "Kotlin"  // Não pode ser null// name = null // Erro de compilação!

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

Para trabalhar com segurança com tipos nullable, o Kotlin oferece vários operadores:

• ?. (safe call) — executa a operação apenas se o valor não for null:

val length = nullableName?.length // Se for null, retorna null




• ?: (elvis operator) — retorna um valor padrão se o objeto for null:

val length = nullableName?.length ?: 0




• !! (not-null assertion) — afirma que o valor não é null (use com cuidado):

val length = nullableName!!.length // Se for null — exceção

Usar null safety em vez de try/catch para verificações de null torna o código mais legível e seguro.

3. Usando Result para uma Abordagem Funcional

Kotlin fornece a classe embutida Result<T>, que representa o resultado de uma operação que pode terminar com sucesso ou com erro. Esta é uma alternativa ao try/catch, baseada em programação funcional.

Exemplo 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("Sucesso: $value")    }.onFailure { error ->        println("Erro: ${error.message}")    }

    // Ou pode obter o valor com um padrão    val value = result.getOrDefault(0)    println("Valor: $value")}

runCatching é uma função wrapper conveniente que captura qualquer exceção e retorna um Result. Você pode combinar Result com encadeamento de chamadas, o que