30.0.0.14.f - Arreglar y Añadir todos los post sobre excepciones

_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**.
 

_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

_posts/javaSE/excepciones/2022-05-18-excepciones-throwable.md → _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``

_posts/javaSE/excepciones/2022-06-09-java-error.md

@@ -19,7 +19,7 @@ page_css:
   - /assets/css/mi-css.css
 ---
 
-## Error
+## Concepto
 
 > ``Errores Irrecuperables``
 

_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``

_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...)
+  }
+}
+```

_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``

_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