Manejo de excepciones de Kotlin | intentar, atrapar, lanzar y finalmente

Una excepción es un evento no deseado o inesperado que ocurre durante la ejecución de un programa, es decir, en tiempo de ejecución, que interrumpe el flujo normal de las instrucciones del programa. El manejo de excepciones es una técnica mediante la cual podemos manejar errores y evitar caídas en el tiempo de ejecución que pueden detener nuestro programa.

Hay dos tipos de excepciones:

1. Excepción comprobada : excepciones que normalmente se establecen en los métodos y se verifican en el momento de la compilación, por ejemplo, IOException, FileNotFoundException, etc.
2. Excepción no verificada : excepciones que generalmente se deben a errores lógicos y se verifican en el tiempo de ejecución, por ejemplo, NullPointerException, ArrayIndexOutOfBoundException, etc.

Excepciones de Kotlin –

En Kotlin, solo tenemos excepciones no verificadas y solo se pueden capturar en tiempo de ejecución. Todas las clases de excepción son descendientes de la clase Throwable .

Generalmente usamos la expresión throw para lanzar un objeto de excepción:

throw Exception("Throw me")

Algunas de las excepciones comunes son:

• NullPointerException: se lanza cuando intentamos invocar una propiedad o método en un objeto nulo.
• Excepción aritmética: se lanza cuando se realizan operaciones aritméticas no válidas en números. por ejemplo, dividir por cero.
• SecurityException: se lanza para indicar una violación de seguridad.
• ArrayIndexOutOfBoundException: se lanza cuando intentamos acceder al valor de índice no válido de una array.

Programa Kotlin para lanzar excepciones aritméticas –

fun main(args : Array<String>){
    var num = 10 / 0      // throws exception
    println(num)
}

Producción:

Exception in thread "main" java.lang.ArithmeticException: / by zero

En el programa anterior, inicializamos la numvariable con el valor 10/0 , pero sabemos que en aritmética no se permite dividir por cero. Mientras intentamos ejecutar el programa, arroja una excepción.

Para resolver este problema, tenemos que usar el bloque try-catch.

Bloque de prueba y captura de Kotlin –

En Kotlin, usamos el bloque try-catch para el manejo de excepciones en el programa. El bloque try encierra el código que es responsable de lanzar una excepción y el bloque catch se usa para manejar la excepción. Este bloque debe escribirse dentro de los métodos principal u otros. El bloque de prueba debe ir seguido del bloque de captura o del bloque finalmente, o de ambos.

Sintaxis para el bloque try-catch –

try {
   // code that can throw exception
} catch(e: ExceptionName) {
   // catch the exception and handle it
}

Programa Kotlin de manejo de excepciones aritméticas usando el bloque try-catch –

import kotlin.ArithmeticException
  
fun main(args : Array<String>){
    try{
        var num = 10 / 0
    }
    catch(e: ArithmeticException){
        // caught and handles it
        println("Divide by zero not allowed")
    }
}

Producción:

Divide by zero not allowed

Explicación:
En el programa anterior, hemos utilizado el bloque try-catch. La numvariable que puede generar una excepción está encerrada entre las llaves del bloque de prueba porque la división por cero no está definida en la aritmética. La excepción capturada por el bloque catch y ejecuta la println()instrucción.

El bloque try-catch de Kotlin como expresión:

Como ya sabemos, expresión siempre devuelve un valor. Podemos usar el bloque try-catch de kotlin como una expresión en nuestro programa. El valor devuelto por la expresión será la última expresión del bloque try o la última expresión del bloque catch. Si ocurre una excepción en el código, el bloque catch devuelve el valor.

Programa Kotlin de usar try-catch como una expresión –

fun test(a: Int, b: Int) : Any {
    return try {
        a/b
        //println("The Result is: "+ a / b)
    }
    catch(e:Exception){
        println(e)
        "Divide by zero not allowed"
    }
}
// main function
fun main(args: Array<String>) {
    // invoke test function
    var result1 = test(10,2  ) //execute try block
    println(result1)
    var result = test(10,0 )   // execute catch block
    println(result)
}

Producción:

5
java.lang.ArithmeticException: / by zero
Divide by zero not allowed

En el código anterior, hemos usado try-catch como expresión. Declare una prueba de función en la parte superior del programa y devuelva un valor usando el bloque try-catch. Hemos invocado la testfunción desde el método principal y pasado los valores de los parámetros (10,2). La función de prueba evalúa los argumentos y devuelve el valor de prueba (10/2 = 5) . Pero en la siguiente llamada, pasamos (b=0) y esta vez se captura la excepción y se devuelve la expresión del bloque catch.

Kotlin finalmente bloquea –

En Kotlin, el bloque finalmente siempre se ejecuta independientemente de si el bloque catch maneja o no una excepción. Por lo tanto, se utiliza para ejecutar una declaración de código importante.
También podemos usar el bloque finalmente con el bloque de prueba y omitir el bloque de captura desde allí.

Sintaxis de bloque finalmente con bloque de prueba:

try {
   // code that can throw exception
} finally {
   // finally block code
}

Programa Kotlin de usar el bloque finalmente con el bloque de prueba bloque –

fun main(args : Array<String>){
    try{
        var ar = arrayOf(1,2,3,4,5)
        var int = ar[6]
        println(int)
    }
  finally {
        println("This block always executes")
    }
}

Producción:

Este bloque siempre ejecuta una
excepción en el subproceso «principal» java.lang.ArrayIndexOutOfBoundsException: índice 6 fuera de los límites para la longitud 5

En el programa anterior, hemos utilizado el bloque try con finalmente y hemos saltado el bloque catch. Aquí, la excepción no es manejada por el bloque catch sino que ejecuta el último bloque.

Sintaxis de bloque finalmente con bloque try-catch –

try {
   // code that can throw exception
} catch(e: ExceptionName) {
   // catch the exception and handle it.
} finally {
  // finally block code
}

También podemos usar los bloques try, catch y finalmente todos juntos.
Programa Kotlin de usar el bloque finalmente con el bloque try-catch-

fun main (args: Array<String>){  
    try {  
        var int = 10 / 0  
        println(int)  
    } catch (e: ArithmeticException) {  
        println(e)  
    } finally {  
        println("This block always executes")  
    }  
}  

Producción:

java.lang.ArithmeticException: / by zero
This block always executes

Palabra clave de lanzamiento de Kotlin –

En Kotlin, usamos la palabra clave throw para lanzar una excepción explícita. También se puede utilizar para lanzar una excepción personalizada.

Programa Kotlin de usar la palabra clave throw –

fun main(args: Array<String>) {
    test("abcd")
    println("executes after the validation")
}
fun test(password: String) {
    // calculate length of the entered password and compare
    if (password.length < 6)
        throw ArithmeticException("Password is too short")
    else
        println("Strong password")
}

Producción:

Exception in thread "main" java.lang.ArithmeticException: Password is too short