Manejo de excepciones en Kotlin con ejemplos

Las excepciones son el error que se produce en el tiempo de ejecución e interrumpe el flujo de ejecución del programa. Básicamente, la excepción es el evento no deseado que ocurre en tiempo de ejecución. El método por el cual podemos manejar este tipo de error se llama Manejo de excepciones.

Tipos de excepciones

1. Excepción comprobada: las excepciones que ocurren en el momento de la compilación, o podemos decir que verificadas en el momento de la compilación, se denominan Excepción comprobada. Ejemplo: IOException , alguna excepción relacionada con archivos , etc.
2. Excepción no verificada: las excepciones que ocurren en el tiempo de ejecución se denominan excepciones no verificadas. Ejemplo: excepción OutofBound .

Nota: En Kotlin solo tenemos Excepciones sin marcar que solo se dan cuenta en el tiempo de ejecución.

¿Cómo manejar las excepciones?

Tenemos algunas palabras clave que nos ayudan a manejar las excepciones.

1. Try            // Esto intentará encontrar la excepción
2. Throw      // Si se encuentra una excepción, lanzará la excepción
3. Catch       // Después de lanzarlo, atrapará la excepción y ejecutará su cuerpo.

Tenemos una palabra clave más llamada Finalmente , siempre se ejecutará, ya sea que tengamos una excepción o no. En esto, tenemos algunos códigos importantes que siempre deben ejecutarse.

Nota: Si el programa sale por exitProcess(Int) o abort() , entonces no se ejecutará el final.

¿Cómo usar try-catch y finalmente?

try
{
  // your code which
  // may throw an exception
}
catch(ex : ExceptionName)
{
  // Exception handle code
}
finally
{
  // this will execute every time
  // either we found exception or not
}

Ejemplo 1:  dividir por cero 

fun main()
{
    try
      {
      // calling the function
      divide(10, 0) 
    }
    catch (ex : Exception)
    {
      // or you can also write your
      // own handle here
      println(ex.message) 
    }
}
  
// function which may give exception
fun divide(a : Int, b : Int)
{
    if (b == 0)
        throw Exception("Divide by zero") 
    // even if you didn't write
    // this throw it will work fine.
    println("Division is :" + a / b)
}

Producción:

Divide by zero

Ejemplo 2: Probemos el mismo código con try-catch y finalmente.

fun main()
{
    // first try block
    try 
    {
      // didn't throw any exception
      divide(20, 10) 
    }
    catch (ex : Exception)
    {
      // or you can also write your
      // own handle here
      println(ex.message) 
    }
    finally 
    {
      println("I'm executed")
    }
      
    // 2nd try block
    try 
    {
      // throw an exception
      divide(10, 0) 
    }
    catch (ex : Exception)
    {
      // or you can also write your
      // own handle here
      println(ex.message) 
    }
    finally 
    {
      println("I'm executed")
    }
}
  
fun divide(a : Int, b : Int)
{
    if (b == 0)
        throw Exception("Divide by zero") 
    println("Division is :" + a / b)
}

Producción:

Division is : 2
I'm executed
Divide by zero
I'm executed

Tenga en cuenta que en el ejemplo anterior, finalmente se ejecuta en ambos casos, ya sea que ocurra una excepción o no.