diff --git a/008_java_oo/debug_break_point.png b/008_java_oo/debug_break_point.png new file mode 100644 index 0000000..8f3e801 Binary files /dev/null and b/008_java_oo/debug_break_point.png differ diff --git a/008_java_oo/eclipse/pila_ejecucion/src/pila_ejecucion/Flujo.java b/008_java_oo/eclipse/pila_ejecucion/src/pila_ejecucion/Flujo.java new file mode 100644 index 0000000..286290e --- /dev/null +++ b/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() { + + } + } +} \ No newline at end of file diff --git a/008_java_oo/eclipse/pila_ejecucion/src/pila_ejecucion/Flujo2.java b/008_java_oo/eclipse/pila_ejecucion/src/pila_ejecucion/Flujo2.java new file mode 100644 index 0000000..94d52bb --- /dev/null +++ b/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() {} + } +} \ No newline at end of file diff --git a/008_java_oo/eclipse/pila_ejecucion/src/pila_ejecucion/MiExcepcion.java b/008_java_oo/eclipse/pila_ejecucion/src/pila_ejecucion/MiExcepcion.java new file mode 100644 index 0000000..2892226 --- /dev/null +++ b/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); + } +} diff --git a/008_java_oo/eclipse/pila_ejecucion/src/pila_ejecucion/MiExcepcion2.java b/008_java_oo/eclipse/pila_ejecucion/src/pila_ejecucion/MiExcepcion2.java new file mode 100644 index 0000000..4aef778 --- /dev/null +++ b/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); + } +} diff --git a/008_java_oo/excepciones.md b/008_java_oo/excepciones.md new file mode 100644 index 0000000..df6e1ca --- /dev/null +++ b/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 +``` + + + +```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**. + diff --git a/008_java_oo/primeros_pasos.md b/008_java_oo/primeros_pasos.md index 86b9b31..eee23fa 100644 --- a/008_java_oo/primeros_pasos.md +++ b/008_java_oo/primeros_pasos.md @@ -12,6 +12,7 @@ de jetbrains (2022). ```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 JDK subgraph JRE 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