Unlimited Plugins, WordPress themes, videos & courses! Unlimited asset downloads! From $16.50/m
Advertisement
  1. Code
  2. Kotlin
Code

Kotlin Desde Cero: Manejo de Excepciones

by
Difficulty:IntermediateLength:MediumLanguages:
This post is part of a series called Kotlin From Scratch.
Kotlin From Scratch: Abstract Classes, Interfaces, Inheritance, and Type Alias

Spanish (Español) translation by Rafael Chavarría (you can also view the original English article)

Kotlin es un lenguaje de programación moderno que compila a código byte Java. Es gratuito y de código abierto, y hace programar para Android incluso más divertido.

En el artículo anterior, aprendiste más sobre programación orientada a objetos adentrándote a clases abstractas, interfaces, herencia y tipos de aliases en Kotlin.

En este artículo, continuarás aprendiendo sobre programar en Kotlin aprendiendo sobre excepciones y cómo manejarlas.

1. Manejo de Excepciones

Las excepciones son usadas para indicar un problema en nuestro código durante una ejecución de programa. Manejo de excepciones es la capacidad de abordar (o manejar) la excepción que podría ocurrir. Si no manejamos cualquier excepción que ocurra, nuestro programa detendrá abrúptamente la ejecución---cerrando nuestra aplicación inmediatamente.

El manejo de excepciones permite a nuestro programa continuar la ejecución incluso si hubo una excepción (aunque es altamente recomendable reportar tus excepciones usando una herramienta de reporteo de errores como Crashlytics).

En Java, tenemos dos clases de excepciones: revisadas y no revisadas. Explicaré de manera breve ambas, pero comenzaremos con las excepciones no revisadas.

Excepciones No Revisadas

Estas son excepciones que son arrojadas debido a fallas en tu código. Son una subclase directa o indirecta de la superclase RuntimeException.

Los ejemplos de excepciones no revisadas incluyen:

  • ArithmeticException: lanzada cuando divides entre cero.
  • ArrayIndexOutOfBoundExceptions: arrojada cuando un arreglo ha sido accedido con un índice ilegal.
  • SecurityException: Arrojada por el administrador de seguridad para indicar una violación de seguridad.
  • NullPointerException: arrojada cuando se invoca un método o propiedad de un objeto nulo.

Un método que podría arrojar una excepción no revisada que no contiene ninguna información sobre la excepción arrojada en su declaración de método.

Estos tipos de excepción pueden ser prevenidos codificando correctamente. En el código de arriba, deberíamos haber revisado si el denominador era cero antes de realizar la operación. Para estas excepciones, el desarrollador no necesita atrapar la excepción usando el bloque try...catch. En otras palabras, no estamos forzados por el compilador a encerrar el código que podría disparar la excepción en un bloque try...catch. En su lugar, solo deberíamos asegurar que las excepciones nunca ocurran en primer lugar.

También, recuerda, Kotlin es un lenguaje seguro de nulos. En otras palabras, puede ayudarnos a evitar tener NullPointerExceptions en nuestro código. Puedes leer el artículo Nulidad, Ciclos, y Condiciones para obtener un recordatorio sobre seguridad de nulidad en Kotlin.

Excepciones Revisadas en Java

Un método que podría devolver una exepción revisada necesita declararlo en su firma de método usando la palabra clave throws. Si llamas un método que arroja una excepción revisada, necesitarás arrojarla de nuevo desde tu función o atraparla y manejarla usando un bloque try...catch.

Las excepciones revisadas son excepciones que son revisadas en tiempo de compilación. Este tipo de excepciones heredan de la clase Exception. Como ejemplo de este tipo de excepción está IOException. Esto puede ocurrir cuando intentas acceder a un archivo que no puede ser abierto porque no existe. (FileNotFoundException es una subclase de IOException.)

En el código anterior, usamos un bloque try...catch para manejar la IOException dentro del método editFile(). Ahora podemos llamar al método editFile() de manera normal, y el compilador no se quejará.

Viendo al código de abajo, hemos refactorizado el método para usar en lugar de la palabra clave throws en la firma del método. Esto indica a los llamadores que necesitan manejar la excepción IOException que podría ser arrojada cuando se llama al método editFile().

Para llamar al método de arriba, necesitamos encerrarlo en un bloque try...catch para manejar la excepción.

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

2. Excepciones en Kotlin

La principal diferencia entre los mecanismos de excepciones de Kotlin y Java es que todas las excepciones son no revisadas en Kotlin. En otras palabras, no están declaradas de manera explícita en las firmas de función, como lo están en Java.

Aquí, hemos convertido el método editFile() a una función Kotlin. Puedes ver que la función no tiene la declaración throws IOException en su firma de función. throws no es siquiera una palabra clave en Kotlin.

También, podemos llamar a esta función sin rodearla con el bloque try...catch---y el compilador no se quejará. En otras palabras, no hay tal cosa como excepciones revisadas en Kotlin. Todas las excepciones son no revisadas. (Nota que si hay una excepción arrojada, la ejecución del programa se detendrá de manera normal.)

Si creemos que esta excepción podría surgir, aún deberíamos manejarla rodeando al método con un bloque try...catch---pero esto no es forzado por el compilador Kotlin.

Si la excepción arrojada dentro de la función editFile() es una instancia de la clase IOException, nuestro bloque catch será ejecutado, y simplemente imprimiremos el rastro de pila para propósitos de depuración.

El Bloque try...catch

El constructor try con cláusulas catch y finally en Kotlin es similar al de Java.

Aquí, estamos arrojando un objeto Exception dentro del bloque try. Nota que no incluimos la palabra clave new como lo hacemos en Java para crear una nueva instancia. También nota que no especificamos la excepción que será arrojada en la firma de la función como lo haríamos en Java.

Manejamos todas las subclases de tipo Exception en el bloque catch. El bloque opcional finally siempre se ejecuta---es aquí donde típicamente cerramos cualquier recurso o conexiones que fueron abiertas previamente para prevenir fugas de recurso. Por ejemplo, si abres un archivo o creas una base de datos o conexión de red en un bloque try, deberías cerrarlo o liberarlo en un bloque finally.

Nota que en Kotlin el constructor throw es una expresión y puede combinarse con otras expresiones.

También, el constructor try puede ser usado como una expresión.

Aquí, asignamos el valor devuelto desde el bloque try...catch a la variable result. Si el número no es 1, este arroja IllegalArgumentException y el bloque catch es ejecutado. La expresión false en el valor del bloque catch será asignado a la variable result. Si el número es 1 en su lugar, entonces el valor de expresión true será asignado a la variable result.

Java Interop

Las excepciones en Kotlin se comportan de manera normal en Java---pero quiero hacerte consciente de una notación útil llamada @Throws en Kotlin que podría ser de utilidad. Debido a que todas las excepciones en Kotlin son no revisadas, los desarrolladores que consumen tu código Kotlin desde Java podrían no estar conscientes de que tus funciones arrojan excepciones. Sin embargo, aún puedes agregar las posibles excepciones que podrían ser arrojadas a una firma de método con la anotación @Throw. Esto alertará a los llamadores Java de que necesitan manejar la excepción.

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

Aquí, definimos una función Kotlin que puede arrojar una excepción IllegalArgumentException solo si el tipo pasado a la función no es de tipo Int.

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

Esto funciona bien; el compilador no se está quejando. Sin embargo, si queremos comunicar con llamadores Java que la función de nivel superior addNumberToTwo() arroja una excepción, simplemente agregamos la anotación @Throws a la firma de la función.

Esta anotación @Trows puede aceptar una lista separada por comas de argumentos de excepción de clases. En el código de arriba, solo incluímos una clase de excepción---IllegalArgumentException.

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

Si descompilamos la función Kotlin addNumberToTwo(), usando la característica Mostrar Código Byte Kotlin (si estás en IntelliJ IDEA o Android Studio, usamos Herramientas > Kotlin > Mostrar Código Byte Kotlin), veremos el siguiente código Java:

En el código Java generado arriba (algunos elementos del código generado fueron removidos para ser breves), puedes ver que el compilador agregó la palabra clave throws a la firma del método---debido a que incluimos la anotación @Throws.

Conclusión

En este tutorial, aprendiste más sobre programar en Kotlin viendo excepciones. Vimos que Kotlin no tiene excepciones revisadas pero en su lugar, todas las excepciones son no revisadas. También vimos cómo manejar excepciones usando el bloque try...catch y vimos la utilidad de la anotación @Throws en Kotlin para llamadores Java.

Para aprender más sobre el lenguaje Kotlin, recomendé visitar la documentación Kotlin. O revisa algunos de nuestros otros artículos de desarrollo de aplicaciones Android aquí en Envato Tuts!


Advertisement
Advertisement
Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.