Java Excepciones: aulas 1 a 4

008_java_oo/eclipse/pila_ejecucion/src/pila_ejecucion/Flujo.java

@@ -0,0 +1,45 @@
+package pila_ejecucion;
+
+public class Flujo {
+
+    public static void main(String[] args) {
+        System.out.println("Inicio Main");
+        metodo1();
+        System.out.println("Fin Main");
+    }
+
+    public static void metodo1(){
+        System.out.println("Inicio Método1");
+        metodo2();
+        System.out.println("Fin Método1");
+    }
+
+    public static void metodo2(){
+        System.out.println("Inicio Método2");
+        for(int i=1; i<= 4; i++){
+            try {
+                if (i == 2) {
+                    int num = 0;
+                    int resultado = i/num;
+                    System.out.println("Resultado: "+resultado);
+                } else if (i == 3) {
+                    Cuenta c = null;
+                    c.depositar();
+                } else {
+                    String resultado = null;
+                    System.out.println("Resultado: "+resultado.toString());
+                }
+            } catch (ArithmeticException | NullPointerException e) {
+                System.out.println(e.getMessage());
+                e.printStackTrace();
+            }
+        }
+        System.out.println("Fin Método2");
+    }
+    
+    public class Cuenta {
+        void depositar() {
+            
+        }
+    }
+}

008_java_oo/eclipse/pila_ejecucion/src/pila_ejecucion/Flujo2.java

@@ -0,0 +1,43 @@
+package pila_ejecucion;
+
+public class Flujo2 {
+
+    public static void main(String[] args) {
+        System.out.println("Inicio Main");
+        metodo1();
+        System.out.println("Fin Main");
+    }
+
+    public static void metodo1(){
+        System.out.println("Inicio Método1");
+        try {
+            metodo2();
+        } catch (ArithmeticException | MiExcepcion ae) {
+            //System.out.println("Excepción: "+ae.getMessage());
+            ae.printStackTrace();
+        }
+        System.out.println("Fin Método1");
+    }
+
+    public static void metodo2(){
+        System.out.println("Inicio Método2");
+        //ArithmeticException ae = new ArithmeticException();
+        //throw ae;
+        //throw new ArithmeticException("Error aritmético");
+        //throw new MiExcepcion("Mi excepción");
+        try {
+            metodo3();
+        } catch (MiExcepcion2 e2) {
+            e2.printStackTrace();
+        }
+        //System.out.println("Fin Método2");
+    }
+    
+    public static void metodo3() throws MiExcepcion2 {
+        throw new MiExcepcion2("Mi excepcion 2");
+    }
+    
+    public class Cuenta {
+        void depositar() {}
+    }
+}

008_java_oo/eclipse/pila_ejecucion/src/pila_ejecucion/MiExcepcion.java

@@ -0,0 +1,11 @@
+package pila_ejecucion;
+
+public class MiExcepcion extends RuntimeException {
+    public MiExcepcion() {
+        super();
+    }
+
+    public MiExcepcion(String mensaje) {
+        super(mensaje);
+    }
+}

008_java_oo/eclipse/pila_ejecucion/src/pila_ejecucion/MiExcepcion2.java

@@ -0,0 +1,11 @@
+package pila_ejecucion;
+
+public class MiExcepcion2 extends Exception {
+    public MiExcepcion2() {
+        super();
+    }
+
+    public MiExcepcion2(String mensaje) {
+        super(mensaje);
+    }
+}

008_java_oo/excepciones.md

@@ -0,0 +1,255 @@
+# Lanzar y controlar [Excepciones](https://app.aluracursos.com/course/java-excepciones)
+
+
+## Pila de ejecución
+
+Ejemplo visual del [flujo](./eclipse/pila_ejecucion/src/pila_ejecucion/Flujo.java)
+de ejecución
+
+```java
+public class Flujo {
+
+    public static void main(String[] args) {
+        System.out.println("Inicio Main");
+        metodo1();
+        System.out.println("Fin Main");
+    }
+
+    public static void metodo1(){
+        System.out.println("Inicio Método1");
+        metodo2();
+        System.out.println("Fin Método1");
+    }
+
+    public static void metodo2(){
+        System.out.println("Inicio Método2");
+        for(int i =1; i<= 5; i++){
+            System.out.println("i:"+i);
+        }
+        System.out.println("Fin Método2");
+    }
+}
+```
+
+Punto de interrupción **breakpoint** en el IDE
+
+![img](./debug_break_point.png)
+
+## Excepciones
+
+Induciendo error en `metodo2()`, clase
+[Flujo.java](./eclipse/pila_ejecucion/src/pila_ejecucion/Flujo.java)
+
+```java
+    public static void metodo2(){
+        System.out.println("Inicio Método2");
+        for(int i =1; i<= 5; i++){
+            System.out.println("i:"+i);
+        }
+        System.out.println("Fin Método2");
+    }
+```
+
+```java
+Exception in thread "main" java.lang.ArithmeticException: / by zero  <- Tipo de Excepción, donde/cuando
+    at pila_ejecucion.Flujo.metodo2(Flujo.java:19)                   <- último elemento de la pila
+    at pila_ejecucion.Flujo.metodo1(Flujo.java:12)                   <- segundo elemento de la pila
+    at pila_ejecucion.Flujo.main(Flujo.java:7)                       <- primer elemento de la pila
+```
+
+- Donde y Tipo de Excepción se produce
+- Rastro, **traceback** de los elementos en la pila de ejecución
+
+## Manejo de excepciones
+
+```java
+    public static void metodo2(){
+        System.out.println("Inicio Método2");
+        for(int i =1; i<= 5; i++){
+            try {
+                //int num = 0;
+                //int resultado = i/num;
+                //System.out.println("Resultado: "+resultado);
+                String resultado = null;
+                System.out.println("Resultado: "+resultado.toString());
+            } catch (ArithmeticException e) {
+                System.out.println(e.getMessage());
+                e.printStackTrace();
+            } catch (NullPointerException e) {
+                System.out.println(e.getMessage());
+                e.printStackTrace();
+            }
+        }
+        System.out.println("Fin Método2");
+    }
+```
+
+### Creación de excepciones
+
+Clase [Flujo2.java](./eclipse/pila_ejecucion/src/pila_ejecucion/Flujo2.java)
+
+### Ejemplo excepción propia ArithmeticException
+
+```java
+public class Flujo2 {
+
+    public static void main(String[] args) {
+        System.out.println("Inicio Main");
+        metodo1();
+        System.out.println("Fin Main");
+    }
+
+    public static void metodo1(){
+        System.out.println("Inicio Método1");
+        try {
+            metodo2();
+        } catch (ArithmeticException ae) {
+            ae.printStackTrace();
+        }
+        System.out.println("Fin Método1");
+    }
+
+    public static void metodo2(){
+        System.out.println("Inicio Método2");
+        //ArithmeticException ae = new ArithmeticException();
+        //throw ae;
+        throw new ArithmeticException("Error Aritmético");
+    }
+}
+```
+
+```java
+Inicio Main
+Inicio Método1
+Inicio Método2
+java.lang.ArithmeticException: Error aritmético
+	at pila_ejecucion.Flujo2.metodo2(Flujo2.java:26)
+	at pila_ejecucion.Flujo2.metodo1(Flujo2.java:14)
+	at pila_ejecucion.Flujo2.main(Flujo2.java:7)
+Fin Método1
+Fin Main
+```
+
+### Ejemplo clase exception propia heredando de RuntimeException
+
+```java
+    ...
+    public static void metodo1() {
+        System.out.println("Inicio Método1");
+        try {
+            metodo2();
+        } catch (MiExepcion me) {
+            me.printStackTrace();
+        }
+        System.out.println("Fin Método1");
+    }
+
+    public static void metodo2(){
+        System.out.println("Inicio Método2");
+        throw new MiExcepcion("Mi excepción");
+    }
+}
+```
+
+```java
+Inicio Main
+Inicio Método1
+Inicio Método2
+pila_ejecucion.MiExcepcion: Mi excepción
+	at pila_ejecucion.Flujo2.metodo2(Flujo2.java:27)
+	at pila_ejecucion.Flujo2.metodo1(Flujo2.java:14)
+	at pila_ejecucion.Flujo2.main(Flujo2.java:7)
+Fin Método1
+Fin Main
+```
+
+### Ejemplo clase exception propia heredando de RuntimeException
+
+```java
+    ...
+    public static void metodo1(){
+        System.out.println("Inicio Método1");
+        try {
+            metodo2();
+        } catch (MiExcepcion2 me2) {
+            me2.printStackTrace();
+        }
+        System.out.println("Fin Método1");
+    }
+
+    public static void metodo2() throws MiExcepcion2 {
+        System.out.println("Inicio Método2");
+        throw new MiExepcion2("Mi excepción 2");
+    }
+```
+
+```java
+Inicio Método1
+Inicio Método2
+pila_ejecucion.MiExcepcion2: Mi excepcion 2
+	at pila_ejecucion.Flujo2.metodo2(Flujo2.java:29)
+	at pila_ejecucion.Flujo2.metodo1(Flujo2.java:14)
+	at pila_ejecucion.Flujo2.main(Flujo2.java:7)
+Fin Método2
+Fin Método1
+Fin Main
+```
+
+<style>div.mermaid{text-align: center;}</style>
+
+```mermaid
+%%{init: {'theme':'dark'}}%%
+classDiagram
+Throwable --|> Exception
+Exception --|> RuntimeException
+Exception --|> MiExepcion2
+Throwable --|> Error
+RuntimeException --|> ArithmeticException
+RuntimeException --|> NullPointerException
+RuntimeException --|> MiExepcion
+Error --|> StackOverFlow
+```
+
+## Excepciones UN/CHECKED
+
+- **UNCHECKED** Excepciones no verificadas por el compilador.
+- **CHECKED** Excepciones verificadas, el compilador nos obliga a informar
+que se lanzara esta excepción, ***throws***.
+
+
+### Sumario
+
+- Existe una gran jerarquía de clases que representan excepciones. Por ejemplo,
+**ArithmeticException** es hija de **RuntimeException**, que hereda de Exception,
+que a su vez es hija de la clase de excepciones más ancestral, **Throwable**.
+Conocer bien esta jerarquía significa saber cómo usar las excepciones en su
+aplicación.
+
+- **Throwable** es la clase que debe extenderse para poder lanzar un objeto en
+la **pila** (usando la palabra reservada ***throw***)
+
+- Es en la clase **Throwable** donde tenemos casi todo el código relacionado con
+las excepciones, incluyendo `getMessage()` e `printStackTrace()`. El resto de la
+jerarquía tiene solo algunas sobrecargas de constructores para comunicar mensajes
+específicos.
+
+- La jerarquía que comenzó con la clase **Throwable** se divide en excepciones
+y errores. Las **excepciones** se utilizan en los **códigos de aplicación**. Los
+**errores** son utilizados exclusivamente por la **máquina virtual**.
+
+- Las clases que heredan de Error se utilizan para informar errores en la máquina
+virtual. Los desarrolladores de aplicaciones no deben crear errores que hereden
+de Error.
+
+- **StackOverflowError** es un error de **máquina virtual** para informar que la
+pila de ejecución no tiene más memoria.
+
+- Las excepciones se dividen en dos categorías amplias: las que el compilador
+comprueba obligatoriamente y las que no.
+
+  - Los primeros se denominan **checked** y se crean por pertenecer a una jerarquía
+  que no pasa **RuntimeException**.
+
+  - Los segundos están **unchecked** y se crean como descendientes de
+  **RuntimeException**.
+

008_java_oo/primeros_pasos.md

@@ -12,6 +12,7 @@ de jetbrains (2022).
 <style>div.mermaid{text-align: center;}</style>
 
 ```mermaid
+%%{init: {'theme':'dark'}}%%
 graph TD
     A(Código Java)-->B(Ejecutable JAR)
     B-->C(Máquina Virtual JVM)
@@ -187,13 +188,14 @@ public class HolaMundo {
 ## Primeros Pasos
 
 ```mermaid
+%%{init: {'theme':'dark'}}%%
 flowchart LR
 subgraph <b>JDK</b>
 subgraph <b>JRE</b>
   c(JVM)
-  style c fill:#f9f,stroke:#000,stroke-width:2px
+  style c fill:#3f3f3f,stroke:#000,stroke-width:2px
   d(Librerías)
-  style d fill:#f9f,stroke:#000,stroke-width:2px
+  style d fill:#3f3f3f,stroke:#000,stroke-width:2px
 end
   a(Tools)
 end