Manejo de Excepciones en Kotlin: Try-Catch y Lanzamiento de Errores

Estoy empezando con los estudios en programación, pero no entendí la Excepción de Try Catch, me toco ir a YouTube para ver otra forma de explicarlo y realmente hay Tutores que dan ejemplos mas sencillos para entenderlo

fun main(args: Array<String>) {

var nombre : String? = null

// En kotlin, esto regresaría null, 
// pero la propiedad length nunca la ejecutara.
print(nombre?.length)

// Simular una excepión, tratar de evitar el !!
try {
	nombre!!.length
	// Lanzar una exepción NullPointerException
	//throw NullPointerException("Ha ocurrido un error")
} catch (exception : NullPointerException ) {
	println("Ha ocurrido un error")
} finally {
	println("Finalmente ha ocurrido un error.. Cerrando aplicación")
}


val primerValor = 10
val segundoValor = 0

// Asignando el valor que regresa un try/catch
val resultado : Int = try { primerValor / segundoValor } catch  (exception: Exception) { 0 }
print(resultado)
}

OJO: CON EL FINALLY

Dentro de un:

try {
	code...
}

Tu código correrá a menos que alguna línea dentro del try genere una excepción, lo que lanzará el catch. Cambe mencionar que a esta parte del código se le asigna un scope especifico, por lo que si tratas de usar una variable que fue definida dentro de este scope, no podrás usarla dentro de tu catch.

try { 
	code...
} catch(ex : Exception)  { 
	println(ex.message);
	run_exception_code();
} 

El catch solo correrá si se genera una excepción, y normalmente lo usamos como medio de validación donde podemos generar un LOG del evento, asignar un valor por defecto o mandar tu propia excepcion, para ser manejada más adelante.

try { 
	code...
} catch(ex : Exception)  { 
	println(ex.message);
	moreCode...
}  finally {
	finalCode
}

Esta parte del código siempre correra, ya sea que corra bien tu try o haya habido una excepción… incluso correrá si haces un return o tiras una excepción… por lo que normalmente se usa para cerrar recursos que o conexiones que se hayan abierto…

Yo considero que cada vez que se pueda usar el try para evitar un excepcion y que la aplicacion falle se debe usar no lo considero un abuso de la herramienta mas bien para eso se invento.

Ojo!

• Tu no puedes tener un catch o finally sin un try
• Tu no puedes poner codigo entre el try y el catch, o el catch y el finally.
  por ejemplo:

try { callRiskyCode( ) }
x = 7
catch(e: Bad Exception) {}

• un try puede estar seguido de un catch o un finally
• Un try puede tener multiples catch blocks.

Esta explicacion esta en el libro Head First Kotlin en la pagina 244. Un gran libro en ingles que recomiendo mucho!

El último comentario del vídeo no lo entendí bien, ¿a que se refería con que se debe utilizar lo menos posible? ¿el try/catch? porque realmente un buen código tiene que tener un buen manejo de errores y es fundamental también para tener un código seguro; por eso no entendí muy bien ese comentario, quizá se refería a otra cosa y no capté la idea; espero que alguien pueda aclararme esa duda.

En este ejemplo podemos ver como según la excepción que ocurra será el bloque de código que se ejecutara.

println("Ingrese un número entero: ")

    try {
        val input = readLine()?.trim()
        if (input.isNullOrEmpty()) {
            throw NullPointerException("No se proporcionó ninguna entrada")
        }

        val number = input.toInt()
        println("El número ingresado es: $number")
    } catch (e: NumberFormatException) {
        println("Error: El valor ingresado no es un número entero válido")
    } catch (e: NullPointerException) {
        println("Error: ${e.message}")
    } finally {
        println("Fin del programa")
    }

Por ejemplo al no ingresar nada y solo dar un “Enter” el “if” arrojara la excepción de NullPointerException lo que mandara al catch de (e: NullPointerException) ejecutando la línea println(“Error: ${e.message}”) viendo en la consola “Error: No se proporcionó ninguna entrada”.
En caso de ingresar un número con decimales o una cadena de texto causara una “NumberFormatException” lo cual mostrara en consola “Error: El valor ingresado no es un número entero válido”.

Espero les ayude esto, saludos ✌️

¿Para que sirven el Double Bang y el Safe Call?

el doble bang (!!) se utiliza para afirmar que una variable no es nula y lanzar una excepción si lo es, mientras que el modificador ? se usa para indicar que una variable puede ser nula y permite operaciones seguras en ese contexto.

Ten en cuenta que es una buena práctica utilizar el operador seguro (?) en lugar del doble bang (!!) siempre que sea posible, ya que el operador seguro evita excepciones no deseadas en tiempo de ejecució

Entiendo que el Try Catch sirve por ejemplo en este caso para ocultar el tipo de error del servidor, me parece que por seguridad es bueno usarlo, ya que por errores de servidores puedes hacer ataques, como por ejemplo saber si al iniciar sesion el correo o la contraseña esta mal escrito, algunos sitios solo ponen error, no dan mas informacion por lo mismo.

Sí, es una buena práctica usar try-catch en Kotlin (y en cualquier otro lenguaje de programación) para manejar excepciones en el código.

Las excepciones son eventos que ocurren durante la ejecución del código y que pueden interrumpir su funcionamiento normal. Cuando ocurre una excepción, el flujo de control del programa se desvía del camino normal y puede ser necesario tomar medidas para manejar la excepción y evitar que el programa se detenga o se comporte de manera inesperada.

La estructura try-catch permite capturar excepciones que se lanzan dentro del bloque try, y manejarlas de manera adecuada dentro del bloque catch correspondiente. Esto permite que el programa continúe su ejecución normalmente, en lugar de detenerse por completo.

Además, el manejo de excepciones puede ayudar a identificar y solucionar errores en el código. Al capturar y registrar las excepciones que ocurren durante la ejecución, se puede obtener información valiosa sobre los problemas que se presentan y corregirlos.

En resumen, el uso de try-catch es una buena práctica para manejar excepciones en Kotlin y asegurarse de que el programa se ejecute de manera adecuada y sin errores.

El código try/catch/finally esta malo.
“finally” no esta bien usado!!

var nombre : String? = null
El ? es que es nullable
nombre?.lenght es una SafeCard
KOTLIN te devuelve el null.

Para gestionarlo este tipo de errores:

Usamos los try catch.
try {
throw NullPointerException(“Referencia nula”)
} catch (exception : NullPointerException){
println(“Ha ocurrido un error”)
} finally {
println( “Finalmente ha ocurrido un error . . Cerrando aplicación”)
}

Ejemlo de uso de librería matemática

val primerValor = 0
val segundoValor = 10
val resultado : Int = try { primerValor / segundoValor } catch (exception : Exception) { 0 }
println(resultado)

Se usa en ciertos casos de librerías específicas, no hay que abusar de ellas

Para quienes aún están confundidos con el null-safety, les explico y les dejo un enlace de Android Developers que lo explica bastante bien:
https://developer.android.com/codelabs/basic-android-kotlin-compose-nullability?hl=es-419#0

En Kotlin, los valores de tipo _null _se pueden declarar tranquilamente así:

val miVariableNula = null 

Sin embargo, si queremos asignarle valores nulos a otro tipo de variables que no sean únicamente null, lo puedes hacer. De este modo, estaríamos expandiendo el rango de valores que puede tener la variable. Pero para ello, tenemos que usar ?.
El operador ? amplía el dominio de una variable para que además acepte null, la convierte en tipo nullable. De esta forma, le dices a Kotlin “Ey, esta variable podría ser nula”, ya sea porque un usuario envió un formulario vacío o no ha iniciado sesión para acceder a tu aplicación, por ejemplo.

En ocasiones, vas a desear decirle a Kotlin que estás completamente seguro de que el valor que recibirá una variable no será null, y si lo es, es porque algo anda mal con el diseño de la aplicación. Para comunicarle esto a Kotlin, utilizas el operador double-bang !!. A partir de esa línea de código, una variable que habías declarado antes como nullable a través del operador ?, deja de serlo, lo cual ayuda a controlar bastante más el comportamiento del programa de ahí en adelante. Si ocurre una excepción de tipo NullPointerException en algún punto del programa luego de que hayas declarado tu variable como non-nullable con el operador !!, es porque algo anda mal con esa variable que está recibiendo un valor nulo sin que tú lo hayas permitido.
Esto es muy positivo porque es mejor que te des cuenta que algo anda mal con el programa en lugar de que presente errores sin que tú lo sepas por valores nulos que fueron reasignados a la variable que no quieres que los reciba.

Cuando te das cuenta que dicha variable está recibiendo valores nulos sin tu permiso (es decir, se está lanzando NullPointerException) puedes actuar en consecuencia. Puedes analizar el programa y entender por qué tu variable está recibiendo null y modificarlo. También puedes manejar la excepción NullPointerException usando un bloque de try catch. O también puedes evitar la nulidad en la declaración utilizando el operador _elvis _?: que intenta asignarle un valor a una variable, pero si dicho valor resulta ser nulo, entonces asigna otro valor por defecto.

Es por esto que se dice que Kotlin es un lenguaje con null-safety, es decir, que provee herramientas para un excelente control de las variables nulas.
Espero les haya servido.

Para quienes aún están confundidos con el null-safety, les explico:

En Kotlin, los valores de tipo null se pueden declarar tranquilamente así:

val miVariableNula = null 

Sin embargo, si queremos asignarle valores nulos a otro tipo de variables que no sean únicamente null, lo puedes hacer. De este modo, estaríamos expandiendo el rango de valores que puede tener la variable. Pero para ello, tenemos que usar ?.
El operador ? amplía el dominio de una variable para que además acepte null, la convierte en tipo nullable. De esta forma, le dices a Kotlin “Ey, esta variable podría ser nula”, ya sea porque un usuario envió un formulario vacío o no ha iniciado sesión para acceder a tu aplicación, por ejemplo.

En ocasiones, vas a desear decirle a Kotlin que estás completamente seguro de que el valor que recibirá una variable no será null, y si lo es, es porque algo anda mal con el diseño de la aplicación. Para comunicarle esto a Kotlin, utilizas el operador double-bang !!. A partir de esa línea de código, una variable que habías declarado antes como nullable a través del operador ?, deja de serlo, lo cual ayuda a controlar bastante más el comportamiento del programa de ahí en adelante. Si ocurre una excepción de tipo NullPointerException en algún punto del programa luego de que hayas declarado tu variable como non-nullable con el operador !!, es porque algo anda mal con esa variable que está recibiendo un valor nulo sin que tú lo hayas permitido.
Esto es muy positivo porque es mejor que te des cuenta que algo anda mal con el programa en lugar de que presente errores sin que tú lo sepas por valores nulos que fueron reasignados a la variable que no quieres que los reciba.

Cuando te das cuenta que dicha variable está recibiendo valores nulos sin tu permiso (es decir, se está lanzando NullPointerException) puedes actuar en consecuencia. Puedes analizar el programa y entender por qué tu variable está recibiendo null y modificarlo. También puedes manejar la excepción NullPointerException usando un bloque de try catch. O también puedes evitar la nulidad en la declaración utilizando el operador _elvis _?: que intenta asignarle un valor a una variable, pero si dicho valor resulta ser nulo, entonces asigna otro valor por defecto.

Es por esto que se dice que Kotlin es un lenguaje con null-safety, es decir, que provee herramientas para un excelente control de las variables nulas.
Espero les haya servido.

El bloque try-catch en Kotlin y Java se utiliza para el manejo de excepciones en el código. El bloque try encierra el código que puede lanzar una excepción y el bloque catch se utiliza para manejar la excepción. La excepción se puede capturar en un bloque catch y se puede procesar de acuerdo a las necesidades. El bloque try debe estar seguido de un bloque catch o un bloque finally o ambos. Además, en Kotlin, el bloque try también se puede usar como una expresión que devuelve un valor.

try {
    int x = 10;
    int y = 0;
    int z = x / y;
    System.out.println("Resultado: " + z);
} catch (ArithmeticException e) {
    System.out.println("No se puede dividir entre cero!");
}

En este ejemplo, el bloque try intenta dividir un entero entre cero. Esto generará una excepción ArithmeticException, que se manejará en el bloque catch. El resultado será: “No se puede dividir entre cero!”.

Es recomendable evitar los Try / Catch, puedes validar de otras maneras

var name:String? = null

if (name != null)
{
    println("Hello $name")
}
else
{
    println("name is null exit ")
    return
}

try {
        nombre!!.length;
    }catch (excepcion : NullPointerException){//Para ser mas especificos en la captura del error.
        println("Ha ocurrido un error");
    } finally {
        println("Agrega un valor a la variable: ");
        nombre = readln();
        println("Ahora la variable contiene el dato $nombre");
    }

var nom: String? = null
    try {
        throw NullPointerException("Referencia null")
    }catch (exepcion: NullPointerException){
        println("Ha ocurrido un error")
    }finally {
        println("Cerrando aplicacion")
    }

    val primerVal = 10
    val segundoVal= 0
    val resultado : Int = try {primerVal / segundoVal} catch (exp : Exception){ 0 }
    println(resultado)

Hola Comunidad.
Con respecto al comentario: no se debe de abusar de los manejos de errores.

Puede sonar controversial pero comparto el siguiente enlace:
https://elizarov.medium.com/kotlin-and-exceptions-8062f589d07

Esta en ingles pero tiene un ejemplo bastante claro.

Code desarrollado en la clase:

OJO: Es una mala práctica y debes limitar su uso al máximo.

fun main(args: Array<String>) {
    
    var nombre : String? = null
    try {
        throw NullPointerException("Null reference")
    } catch (excepcion : NullPointerException){
        println("Ha ocurrido un error")
    } finally {
        println("Finalmente ha ocurrido un error... Cerrando aplicacion")
    }

    val primerValor = 10
    val segundoValor = 0
    val resultado : Int = try {
        primerValor/segundoValor
    } catch (excepcion : Exception) {
        0
    }
    println(resultado)
}

Muy util el try catch