diff --git a/_posts/javaSE/excepciones/2022-05-03-java-runtime-exception.md b/_posts/javaSE/excepciones/2022-05-03-java-runtime-exception.md index 99ea6e17..4c425afb 100755 --- a/_posts/javaSE/excepciones/2022-05-03-java-runtime-exception.md +++ b/_posts/javaSE/excepciones/2022-05-03-java-runtime-exception.md @@ -18,7 +18,7 @@ page_css: - /assets/css/mi-css.css --- -## Runtime Exception +## Concepto * Es la **superclase** de aquellas ``excepciones`` que se pueden lanzar durante el funcionamiento normal de la **máquina virtual de Java**. diff --git a/_posts/javaSE/excepciones/2022-05-16-java-excepciones.md b/_posts/javaSE/excepciones/2022-05-16-java-excepciones.md index 3aa230cf..4d488073 100755 --- a/_posts/javaSE/excepciones/2022-05-16-java-excepciones.md +++ b/_posts/javaSE/excepciones/2022-05-16-java-excepciones.md @@ -19,7 +19,7 @@ page_css: - /assets/css/mi-css.css --- -## Excepciones +## Concepto * Es un **evento** que ocurre durante la ``ejecución de un programa`` que rompe el **flujo normal** de ``ejecución`` @@ -42,12 +42,16 @@ throws , throw , try , catch , finally ### Errores Compilación * **Errores sintácticos** + * Cuando escribimos mal el nombre de una ``palabra clave`` , llamada a un ``método`` o ``clase`` * **Errores de Compilación** * Cuando llamamos a un ``método`` que no existe + * Nos falta o nos sobra ``parámetros`` en la invocación a un ``método`` de cualquier tipo + * Asignación de una ``variable`` de ``tipo entero`` a otra del tipo carácter + * Al faltarnos un ``paréntesis`` al cerrar un ``método`` ### Tipos de Excepciones @@ -75,11 +79,17 @@ throws , throw , try , catch , finally ### Subclase Error de la clase Throwable * Problemas graves que una aplicación no podría detectar ya que estos errores son condiciones anormales que nunca deberían ocurrir + * No podemos anticiparnos al error o al problema ni podemos recuperarnos de ellos + * Ejemplo + * ThreadDeath error + * Problema de hardware + * Desbordamiento de memoria (StackOverFlow) en la JVM + * Falta de memoria #### Subclase de la Clase Error @@ -96,4 +106,5 @@ throws , throw , try , catch , finally ### Subclase Exception de la clase Throwable * La ``clase Exception`` y sus ``subclases`` son una forma de indicar que una aplicación podría querer capturar y gestionar los errores que producen en ella + * ``RuntimeException`` sería la subclase descendiente de ``Exception`` más usada diff --git a/_posts/javaSE/excepciones/2022-05-18-excepciones-throwable.md b/_posts/javaSE/excepciones/2022-05-18-java-excepciones-throwable.md similarity index 98% rename from _posts/javaSE/excepciones/2022-05-18-excepciones-throwable.md rename to _posts/javaSE/excepciones/2022-05-18-java-excepciones-throwable.md index ce732b56..32a63bc6 100755 --- a/_posts/javaSE/excepciones/2022-05-18-excepciones-throwable.md +++ b/_posts/javaSE/excepciones/2022-05-18-java-excepciones-throwable.md @@ -19,7 +19,7 @@ page_css: - /assets/css/mi-css.css --- -## Excepciones - Clase Throwable +## Concepto * **API** principal de las **Excepciones** producidas en Java * Son **clases** que contienen ``constructores`` , ``métodos`` y ``atributos`` diff --git a/_posts/javaSE/excepciones/2022-06-09-java-error.md b/_posts/javaSE/excepciones/2022-06-09-java-error.md index 2f482759..2f9a239c 100755 --- a/_posts/javaSE/excepciones/2022-06-09-java-error.md +++ b/_posts/javaSE/excepciones/2022-06-09-java-error.md @@ -19,7 +19,7 @@ page_css: - /assets/css/mi-css.css --- -## Error +## Concepto > ``Errores Irrecuperables`` diff --git a/_posts/javaSE/excepciones/2022-06-09-java-throws.md b/_posts/javaSE/excepciones/2022-06-09-java-throws.md index c1d40efd..1bccb197 100755 --- a/_posts/javaSE/excepciones/2022-06-09-java-throws.md +++ b/_posts/javaSE/excepciones/2022-06-09-java-throws.md @@ -18,11 +18,17 @@ page_css: - /assets/css/mi-css.css --- -## Palabra clave : throws +## Concepto -* La palabra clave ``throws`` (que no debe confundirse con la palabra clave ``throw``) se usa en las declaraciones de ``métodos`` para indicar que el ``método`` puede lanzar el tipo de **excepción** dado. +* **Palabra clave Java** -* Las declaraciones ``throws`` le indican que debe estar preparado para detectar ``excepciones`` de tipo el cual el hayamos indicado en la cabecera del **método** declarado +* Se utiliza en la ``firma`` de un ``método`` para ``indicar`` que este ``método`` podría ``lanzar`` uno de los ``tipos de excepciones`` enumerados + +* Indica que en ese ``método`` podría producirse una ``excepción`` y que esta será ``lanzada`` ``(no capturada dentro del método)`` para que sea atrapada en un ``nivel superior`` + +* No debe confundirse con la palabra clave ``throw`` se usa en las declaraciones de ``métodos`` para indicar que el ``método`` puede ``lanzar`` el tipo de **excepción** dado + +* Las declaraciones ``throws`` le **indican** que debe ``estar preparado`` para detectar ``excepciones`` de tipo el cual el hayamos indicado en la cabecera del **método** declarado ```java class Ejemplo { @@ -32,7 +38,6 @@ public static void lanzarThrows() throws NullPointerException { n.toString(); } } -} ``` * Se pueden especificar varios tipos de **excepción** @@ -46,6 +51,6 @@ void lanzarThrows() throws NullPointerException , InterruptedException, TimeOutE } ``` -Las **excepciones** comprobadas que se lanzan en el **método** deben declararse en la cláusula ``throws`` a menos que estén atrapadas dentro del **método**. +* Las **excepciones** comprobadas que se lanzan en el **método** deben declararse en la cláusula ``throws`` a menos que estén atrapadas dentro del **método** -Las **excepciones no verificadas** no tienen este requisito y, por lo tanto, no deben mencionarse en la declaración ``throws`` +* Las **excepciones no verificadas** no tienen este requisito por lo que no deben mencionarse en la declaración ``throws`` diff --git a/_posts/javaSE/excepciones/2023-05-11-java-throw.md b/_posts/javaSE/excepciones/2023-05-11-java-throw.md new file mode 100755 index 00000000..2cfebdff --- /dev/null +++ b/_posts/javaSE/excepciones/2023-05-11-java-throw.md @@ -0,0 +1,43 @@ +--- +layout: single +title: Java - Throw +date: 2023-05-11 +classes: wide +toc: true +toc_label: "Tabla de contenido" +toc_icon: "clipboard-list" +header: + teaser: /assets/images/java/logo-java-2.jpg +categories: + - java + - java-manual +tags: + - java-throw + - java-excepciones +page_css: + - /assets/css/mi-css.css +--- + +## Concepto + +* Transfiere el control de errores al manejador de excepciones + +* Se utiliza para lanzar explícitamente una excepción desde un método o un bloque de código + +```java + +public class Main { + + static void checkAge(int age) { + if (age < 18) { + throw new ArithmeticException("Access denied - You must be at least 18 years old."); + } else { + System.out.println("Access granted - You are old enough!"); + } + } + + public static void main(String[] args) { + checkAge(15); // Set age to 15 (which is below 18...) + } +} +``` \ No newline at end of file diff --git a/_posts/javaSE/excepciones/2023-05-11-java-tipos-excepciones.md b/_posts/javaSE/excepciones/2023-05-11-java-tipos-excepciones.md new file mode 100755 index 00000000..a4a00b38 --- /dev/null +++ b/_posts/javaSE/excepciones/2023-05-11-java-tipos-excepciones.md @@ -0,0 +1,58 @@ +--- +layout: single +title: Java - Tipos de Excepciones +date: 2023-05-11 +classes: wide +toc: true +toc_label: "Tabla de contenido" +toc_icon: "clipboard-list" +header: + teaser: /assets/images/java/logo-java-2.jpg +categories: + - java + - java-manual +tags: + - java-excepciones +page_css: + - /assets/css/mi-css.css +--- + +## Concepto + +* Las excepciones en Java son eventos que ocurren durante la ``ejecución`` del programa + + * Interrumpen el ``flujo normal`` de las instrucciones + + * Las ``excepciones`` pueden ser ``causadas`` por ``errores`` en el código + + * Ejemplo + + * Intentar dividir un número por cero o acceder a un elemento fuera de los límites de un ````array```` + + * Situaciones externas al programa como un archivo que no se encuentra + + * Una conexión de ``red`` que falla + +* Java proporciona un mecanismo para manejar ``excepciones`` mediante el uso de bloques ``try``, ``catch`` y ``finally`` + +* El ``código`` que puede ``producir`` una ``excepción`` se coloca dentro de un bloque ``try`` + +* Si ocurre una ``excepción`` en el bloque ``try`` el control pasa al primer bloque ``catch`` que puede manejar la ``excepción`` + +* Si no hay ningún bloque ``catch`` que pueda manejar la ``excepción`` el programa terminará + +* El bloque ``finally`` si está presente siempre se ejecutará después del bloque ``try`` ``independientemente`` de si se produjo una excepción o no + +### Tipos de Excepciones + +* ``ArrayIndexOutOfBoundsException`` + + * ``Excepción`` que se produce cuando se intenta acceder a un elemento de un ``array`` con un ``índice`` que está fuera de los límites del ``array`` + + * Ejemplo + + * Tienes un ``array`` de ``5 elementos`` y tratas de acceder al elemento en el ``índice 5`` + + * (No existe porque los índices van de 0 a 4) + + * Se producirá una excepción ``ArrayIndexOutOfBoundsException`` \ No newline at end of file diff --git a/_posts/javaSE/excepciones/2023-05-11-java-try-catch.md b/_posts/javaSE/excepciones/2023-05-11-java-try-catch.md new file mode 100755 index 00000000..9f521d06 --- /dev/null +++ b/_posts/javaSE/excepciones/2023-05-11-java-try-catch.md @@ -0,0 +1,84 @@ +--- +layout: single +title: Java - Try & Catch +date: 2023-05-11 +classes: wide +toc: true +toc_label: "Tabla de contenido" +toc_icon: "clipboard-list" +header: + teaser: /assets/images/java/logo-java-2.jpg +categories: + - java + - java-manual +tags: + - java-try + - java-catch + - java-manejar-excepciones + - java-excepciones +page_css: + - /assets/css/mi-css.css +--- + +## Concepto + +* Estructura de manejador de ``excepciones`` o ``control de errores`` + +* Palabra clave ``try`` + + * Inicia el **bloque de código** que será ``manejado`` en caso de ``errores`` + +* Sentencia ``catch`` + + * Indica el tipo de ``excepción`` que se capturará + + * Puede repetirse varias veces para ``capturar excepciones`` de diferentes tipos + +### Ejemplo 1 : Try Catch Finally + +```java + try { + // Código que puede producir una excepción + int x = 10 / 0; + } catch (ArithmeticException e) { + // Código para manejar la excepción + System.out.println("Ocurrió una excepción: " + e.getMessage()); + } finally { + // Código que siempre se ejecutará después del bloque try + System.out.println("El bloque finally siempre se ejecuta"); + } +``` + +* El código en el bloque ``try`` produce una ``excepción ArithmeticException`` porque intenta dividir un número por cero + +* El control pasa al bloque ``catch`` que maneja la ``excepción`` y muestra un mensaje en la consola + +* Después de eso el bloque ``finally`` se ejecuta y muestra otro mensaje en la consola + +### Ejemplo 2 : Try Catch Finally + +```java + try { + // Código que puede producir una excepción + String s = null; + System.out.println(s.length()); + } catch (NullPointerException e) { + // Código para manejar la excepción + System.out.println("Ocurrió una excepción: " + e.getMessage()); + } finally { + // Código que siempre se ejecutará después del bloque try + System.out.println("El bloque finally siempre se ejecuta"); + } +``` + +* El código en el bloque ``try`` produce una ``excepción NullPointerException`` porque intenta llamar al método ``length()`` en una variable ``String`` que es ``null`` + +* El control pasa al bloque ``catch`` que maneja la ``excepción`` y muestra un mensaje en la consola + +* El bloque ``finally`` se ejecuta y muestra otro mensaje en la consola + +### Como actua las excepciones en el JVM + +* Si una ``excepción`` no es capturada por el listado de la cláusulas ``catch`` entonces es probable que la ``JVM`` inicie el ``reporte`` y la salida de la ``instancia`` completa de la ``JVM`` interrumpiendo todos los ``hilos`` de ``ejecución`` + +* La sentencia ``finally`` se ``ejecutará`` de todas maneras al salir del código