Kotlin From Scratch Manejo de excepciones

Kotlin es un lenguaje de programación moderno que compila a bytecode Java. Es gratis y de código abierto, y hace que la codificación para Android sea aún más divertida.  

En el artículo anterior, aprendió más sobre la programación orientada a objetos explorando clases abstractas, interfaces, herencia y alias de tipo en Kotlin. 

En esta publicación, continuará aprendiendo sobre la programación en Kotlin aprendiendo sobre las excepciones y cómo manejarlas.. 

1. Manejo de excepciones

Las excepciones se utilizan para indicar un problema en nuestro código durante la ejecución de un programa. El manejo de excepciones es la capacidad de abordar (o manejar) la excepción que puede ocurrir. Si no manejamos ninguna excepción que ocurra, nuestro programa detendrá la ejecución de forma abrupta y bloqueará nuestra aplicación inmediatamente.. 

El manejo de excepciones permite que nuestro programa continúe la ejecución incluso si hubiera una excepción (aunque se recomienda registrar sus excepciones e informarlas utilizando una herramienta de informes de fallos como Crashlytics).   

En Java, tenemos dos tipos de excepciones: marcadas y sin marcar. Les explicaré brevemente a ambos, pero comenzaremos con excepciones no verificadas. 

Excepciones no verificadas

Estas son excepciones que se producen debido a fallas en su código. Son una subclase directa o indirecta de la Excepción en tiempo de ejecución superclase. 

Ejemplos de excepciones no verificadas incluyen:

• Excepción aritmética: tirado cuando se divide por cero.
• ArrayIndexOutOfBoundExceptions: se lanza cuando se ha accedido a una matriz con un índice no válido. 
• Excepcion de seguridad: lanzado por el administrador de seguridad para indicar una violación de seguridad.
• Excepción de puntero nulo: se lanza cuando se invoca un método o una propiedad en un objeto nulo.
  

Un método que podría lanzar una excepción no verificada no contiene ninguna información sobre la excepción lanzada en su declaración de método. 

public Integer divideByZero (numerador entero, denominador entero) retorno numerador / denominador;  divideByZero (7, 0) // lanza ArithmeticException

Estos tipos de excepción pueden prevenirse mediante la codificación correcta. En el código anterior, deberíamos haber comprobado si el denominador era cero antes de realizar la operación. Para estas excepciones, el desarrollador no necesita capturar la excepción usando el trata de atraparlo bloquear. En otras palabras, el compilador no nos obliga a envolver el código que podría desencadenar la excepción en un trata de atraparlo bloquear. En su lugar, deberíamos asegurarnos de que las excepciones nunca ocurran en primer lugar.

Además, recuerde, Kotlin es un lenguaje seguro nulo. En otras palabras, puede ayudarnos a evitar NullPointerExceptions en nuestro codigo Puede leer la publicación de Nullability, Loops, and Conditions para obtener una actualización sobre seguridad nula en Kotlin. 

Excepciones comprobadas en Java

Un método que podría lanzar una excepción marcada debe declararlo en su firma de método usando el arroja palabra clave. Si llama a un método que lanza una excepción marcada, debe lanzarla nuevamente desde su función o capturarla y manejarla usando un trata de atraparlo bloquear. 

Las excepciones comprobadas son excepciones que se verifican en el momento de la compilación. Este tipo de excepciones heredan de la Excepción clase. Un ejemplo de este tipo de excepción es IOException. Esto puede ocurrir cuando intenta acceder a un archivo que no se puede abrir porque no existe. (FileNotFoundException es una subclase de IOException.)

// ejecutar en un hilo de fondo public void editFile (Archivo, Texto de cadena) try file.getParentFile (). mkdirs (); FileOutputStream fileOutputStream = new FileOutputStream (archivo); Writer writer = new BufferedWriter (new OutputStreamWriter (fileOutputStream)); prueba writer.write (texto); writer.flush (); fileOutputStream.getFD (). sync ();  finalmente writer.close ();  catch (IOException e) // Registre la excepción e.printStackTrace (); 

En el código anterior, utilizamos una trata de atraparlo bloque para manejar el IOException dentro de editar archivo() método. Ahora podemos llamar al editar archivo() Método como normal, y el compilador no se quejará.. 

editFile (nuevo archivo (""), "mi texto");

Mirando el código de abajo, hemos refactorizado el método para usar el arroja palabra clave en la firma del método. Esto indica a las personas que llaman que necesitan manejar la excepción IOException Eso podría ser lanzado al llamar al método. editar archivo().

// esto debería estar en un hilo de fondo public void editFile (Archivo de archivo, Texto de cadena) lanza IOException file.getParentFile (). mkdirs (); FileOutputStream fileOutputStream = new FileOutputStream (archivo); Writer writer = new BufferedWriter (new OutputStreamWriter (fileOutputStream)); prueba writer.write (texto); writer.flush (); fileOutputStream.getFD (). sync ();  finalmente writer.close (); 

Para llamar al método anterior, necesitamos rodearlo en un trata de atraparlo Bloquear para manejar la excepción..

intente editFile (nuevo archivo (""), "mi texto");  catch (IOException e) e.printStackTrace (); 

Este ha sido un breve vistazo a las excepciones en Java. Veamos ahora cómo maneja Kotlin las excepciones.. 

2. Excepciones en Kotlin

La principal diferencia entre los mecanismos de excepción de Kotlin y Java es que todas las excepciones están desactivadas en Kotlin. En otras palabras, no se declaran explícitamente en las firmas de la función, ya que están en Java.

fun editFile (file: File, text: String) file.parentFile.mkdirs () val fileOutputStream = FileOutputStream (file) val writer = BufferedWriter (OutputStreamWriter (fileOutputStream)) try writer.write (text) writer.flush () fileOutputStream .fd.sync () finalmente writer.close ()

Aquí, hemos convertido el editar archivo() Método a una función de Kotlin. Puedes ver que la función no tiene la lanza IOException Declaración en su firma de función.. arroja ni siquiera es una palabra clave en Kotlin. 

Además, podemos llamar a esta función sin rodearla de la trata de atraparlo Bloque y el compilador no se quejará. En otras palabras, no hay tal cosa como excepciones comprobadas en Kotlin. Todas las excepciones están sin marcar. (Tenga en cuenta que si se produce una excepción, la ejecución del programa se detendrá normalmente). 

Si pensamos que esta excepción podría surgir, deberíamos manejarla rodeando el método con un trata de atraparlo bloque, pero esto no es aplicado por el compilador Kotlin. 

intente editFile (File (""), "text 123") catch (e: IOException) e.printStackTrace ()

Si la excepción lanzada dentro de la editar archivo() La función es una instancia de la IOException clase, nuestra captura el bloque se ejecutará, y simplemente imprimimos el seguimiento de la pila para fines de depuración.

los trata de atraparlo Bloquear

los tratar construir con captura y finalmente Las cláusulas en Kotlin son similares a las de Java.. 

fun foo () try throw Exception ("Mensaje de excepción") catch (e: Exception) println ("Exception manejada") finalmente println ("por dentro bloque")

Aquí, estamos lanzando un Excepción objeto dentro de la tratar bloquear. Note que no incluimos el nuevo palabra clave como lo hacemos en Java para crear una nueva instancia. También tenga en cuenta que no especificamos la excepción que se incluirá en la firma de función como tendríamos que hacerlo en Java. 

Manejamos todas las subclases y clases de tipo. Excepción en el bloque de captura. El opcional finalmente el bloque siempre se ejecuta; aquí es donde normalmente cerramos los recursos o las conexiones que se abrieron anteriormente para evitar pérdidas de recursos. Por ejemplo, si abre un archivo o crea una base de datos o una conexión de red en un tratar bloque, debes cerrarlo o liberarlo en un finalmente bloquear. 

Tenga en cuenta que en Kotlin el lanzar Construir es una expresión y puede combinarse con otras expresiones..

letra val = 'c' resultado val = si (letra en 'a' ... 'z'), otra letra lanza IllegalArgumentException ("Una letra debe estar entre la A y la Z") 

También el tratar constructo puede ser utilizado como una expresión.

fun foo (number: Int) val result = try if (number! = 1) throw IllegalArgumentException () true catch (e: IllegalArgumentException) false println (result) foo (2) // false

Aquí, asignamos el valor devuelto de la trata de atraparlo bloque a la resultado variable. Si el número no es 1, lanza un Argumento de excepción ilegal y el captura Se ejecuta el bloque. los falso expresión en el captura el valor de bloque será asignado a la resultado variable. Si el numero es 1 en cambio, entonces el cierto valor de expresión se asignará a la resultado variable.

Interoperabilidad de Java

Las excepciones en Kotlin se comportan normalmente en Java, pero quiero informarle sobre una anotación útil llamada @Throws en Kotlin eso podría ser útil. Debido a que todas las excepciones en Kotlin no están marcadas, los desarrolladores que consumen su código Kotlin de Java pueden no estar conscientes de que sus funciones generan excepciones. Sin embargo, aún puede agregar las posibles excepciones que podrían generarse a una firma de método con el @Lanzar anotación. Esto alertará a los usuarios de Java de que necesitan manejar la excepción. 

Veamos un ejemplo práctico de esta anotación..

/ * Archivo Functions.kt * / fun addNumberToTwo (a: Any): Int if (a! Is Int) throw IllegalArgumentException ("El número debe ser un número entero") return 2 + a

Aquí, definimos una función de Kotlin que puede lanzar una excepción Argumento de excepción ilegal solo si el tipo pasado a la función no es del tipo En t. 

Llamamos a esta función de nivel superior. addNumberToTwo () directamente desde Java de la siguiente manera:

public void myJavaMethod () Integer result = FunctionsKt.addNumberToTwo (5); System.out.println (resultado); // 7

Esto funciona bien; El compilador no se queja. Sin embargo, si queremos comunicarnos con las personas que llaman en Java, addNumberToTwo () La función de nivel superior lanza una excepción, simplemente agregamos el @Throws anotación a la firma de función. 

@Throws (IllegalArgumentException :: class) fun addNumberToTwo (a: Any): Int if (a! Is Int) throw IllegalArgumentException ("Number debe ser un entero") return 2 + a

Esta @Throws La anotación puede aceptar una lista de argumentos de clases de excepción separados por comas. En el código anterior, solo incluimos una clase de excepción-Argumento de excepción ilegal. 

Ahora tenemos que actualizar nuestro código Java para manejar la excepción..

public void myJavaMethod () lanza IllegalArgumentException Integer result = FunctionsKt.addNumberToTwo (5); System.out.println (resultado); 

Si descompilamos el Kotlin. addNumberToTwo () función, utilizando el Show Kotlin Bytecode característica (si está en IntelliJ IDEA o Android Studio, use Herramientas > Kotlin > Show Kotlin Bytecode), veremos el siguiente código de Java:

//… public static final int addNumberToTwo (@NotNull Object a) lanza la excepción IllegalArgumentException Intrinsics.checkParameterIsNotNull (a, "a"); if (! (a instanceof Integer)) throw (Throwable) (new IllegalArgumentException ("El número debe ser un número entero"));  else return 2 + ((Number) a) .intValue ();  //… 

En el código Java generado anteriormente (algunos elementos del código generado se eliminaron por razones de brevedad), puede ver que el compilador agregó el arroja palabra clave para la firma de método-porque incluimos el @Throws anotación. 

Conclusión

En este tutorial, aprendió más sobre la programación en Kotlin al buscar excepciones. Vimos que Kotlin no ha revisado las excepciones, sino que, en cambio, todas las excepciones están desactivadas. También vimos cómo manejar excepciones usando el trata de atraparlo Bloquear y vio la utilidad de la @Throws Anotación en Kotlin para llamadores de Java.. 

Para obtener más información sobre el idioma Kotlin, recomiendo visitar la documentación de Kotlin. O echa un vistazo a algunas de nuestras otras publicaciones de desarrollo de aplicaciones para Android aquí en Envato Tuts!