El manejo de excepciones en Java es uno de los poderosos mecanismos para manejar errores de tiempo de ejecución causados ​​por excepciones. El manejo de excepciones juega un papel importante en el desarrollo de software. Este artículo lo ayuda a comprender la excepción de Java, la excepción en Java, el manejo de excepciones de Java, la jerarquía de excepciones de Java, los tipos de excepción en Java y mucho más.

¿Qué es el manejo de excepciones en Java?

El manejo de excepciones en Java ayuda a minimizar las excepciones y ayuda a recuperarse de las excepciones. Es uno de los poderosos mecanismos para manejar excepciones de tiempo de ejecución y lo hace libre de errores. El manejo de excepciones ayuda a mantener el flujo del programa. Un manejo de excepciones se define como una condición anormal que puede ocurrir en tiempo de ejecución y perturbar el flujo normal del programa.

Lea también Tutorial Java para principiantes

¿Qué es una excepción?

Una expectativa es un evento inesperado que ocurre mientras se ejecuta el programa, que perturba el flujo normal del código.

Manejo de excepciones en Java con un ejemplo:

Digamos,

statement
statement
statement
exception ………… an exception occurred, then JVM will handle it and will exit the prog.
statement
statement
statement

Para el manejo de excepciones, hay 2 enfoques posibles

1.JVM

Si una excepción no se maneja explícitamente, JVM asume la responsabilidad de manejar la excepción.

Una vez que se maneja la excepción, JVM detendrá el programa y no se ejecutará más el código.

import java.util.*; class Main { public static void main (String[] args) { System.out.println(5/0); System.out.println("End of program!"); }
}

Error de tiempo de ejecución:

 Excepción en el subproceso "main" java.lang.ArithmeticException: / por cero en Main.main(File.java:5) 

2. Developer

Los desarrolladores pueden escribir explícitamente la implementación para manejar la excepción. Una vez que se maneja una excepción, la ejecución normal del código continuará.

Preferible: maneje las excepciones para asegurarse de que su código se ejecute normalmente.

Jerarquía de excepciones de Java

Jerarquía de excepciones: A continuación se muestra el manejo de excepciones en la jerarquía de manejo de Java.

• Desechable –
  • Es la clase raíz para la jerarquía de excepciones en Java. 
  • Está en el paquete java.lang.
• Error –
  • Subclase de Throwable.
  • Consiste en una condición anormal que está fuera de nuestro control y depende del entorno.
  • No se pueden manejar y siempre resultarán en la detención del programa.
  • Por ejemplo: StackOverFlowError que puede ocurrir en bucle infinito o recursividad
• Excepción –
  • Subclase de Throwable.
  • Consisten en condiciones anormales que se pueden manejar explícitamente.
  • Si uno maneja la excepción, nuestro código continuará ejecutándose sin problemas.

Tipos de excepción en Java

• Excepciones marcadas
  • Esas excepciones que se verifican en tiempo de compilación comprenden excepciones verificadas.
  • Son clases secundarias de Exception excepto RuntimeException.
  • El programa no compilará si no se manejan.
  • Ejemplo: IOException, ClassNotFoundException, etc.
• Excepciones sin marcar
  • Esas excepciones que se verifican en tiempo de ejecución comprenden excepciones no verificadas.
  • Son clases secundarias de RuntimeException.
  • Dan errores de tiempo de ejecución si no se manejan explícitamente.
  • Ejemplo: ArithmeticException, NullPointerException, etc.

Diferencia entre excepción marcada y no marcada

Índice de excepciones de Java

Palabras clave de excepción de Java

El manejo de excepciones en Java se administra a través de cinco palabras clave: probar, atrapar, lanzar, lanzar y finalmente. Aquí hay 5 palabras clave que se usan para manejar excepciones en Java

Bloque Try-Catch de Java

Sintaxis de prueba y captura:

try{
}
catch(Exception e){
}

• Ejemplo de intento de captura:

public class ExceptionDemo { public static void main (String[] args) { int a=10; for(int i=3;i>=0;i--) try{ System.out.println(a/i); }catch(ArithmeticException e){ System.out.println(e); } }
}

Salida:

3 5 10 java.lang.ArithmeticException: / por cero 

• try El bloque contiene el código que podría generar una excepción. No escriba nada adicional en las declaraciones de prueba después de que la excepción no se ejecute si se produjo la excepción. Try debe ser seguido inmediatamente por catch o finalmente block.

public class ExceptionDemo { public static void main (String[] args) { int a=10; for(int i=3;i>=0;i--) try{ System.out.println(a/i); } }
}

Error en tiempo de compilación:

prog.java:5: error: 'intentar' sin 'atrapar', 'finalmente' o declaraciones de recursos probar{ ^ 1 error 

• El bloque catch se usa para capturar la excepción lanzada por declaraciones en el bloque try. La captura debe seguir al intento, de lo contrario, dará un error de tiempo de compilación.

public class ExceptionDemo { public static void main (String[] args) { int a=10; for(int i=3;i>=0;i--) try{ System.out.println(a/i); } System.out.println("between try and catch"); catch(ArithmeticException e){ System.out.println(e); } }
} 

Error de tiempo de compilación:

prog.java:5: error: 'intentar' sin 'atrapar', 'finalmente' o declaraciones de recursos probar{ ^ prog.java:9: error: 'atrapar' sin 'intentar' catch(ArithmeticException e){ ^ 2 errores 

Cosas para recordar:

No guarde ningún código después de la declaración que es propensa a la excepción. Porque si ocurriera una excepción, saltará directamente al bloque de captura o finalmente, ignorando todas las demás declaraciones en el bloque de prueba.

class Main { public static void main (String[] args) { try { System.out.println(4/0); //will not get printed System.out.println("end of try!"); }
catch(ArithmeticException e) { System.out.println("divide by 0"); } }
}

Salida:

dividir por 0

• Mientras captura la excepción en el bloque catch, puede tener directamente la clase de excepción o su superclase.

Ejemplo: excepción exacta

class Main { public static void main (String[] args) { try{ System.out.println(4/0); } //ArithmeticException catch(ArithmeticException e){ System.out.println("divide by 0"); } }
}

Salida:

dividir por 0

Ejemplo: Superclase de Excepción Exacta

class Main { public static void main (String[] args) { try{ System.out.println(4/0); } //superclass of ArithmeticException catch(Exception e){ System.out.println("divide by 0"); } }
}

Salida:

dividir por 0

Bloque de captura múltiple de Java

Si tiene varias capturas, debe mantener la jerarquía de subclase a superclase.

Incorrecto:

class Main { public static void main (String[] args) { try{ System.out.println(4/0); }catch(Exception e) { System.out.println("Exception : divide by 0"); }catch(ArithmeticException e) { System.out.println("ArithmeticException :divide by 0"); } }
}

Error en tiempo de compilación:

 prog.java:11: error: la excepción ArithmeticException ya se detectó }catch(ArithmeticException e) ^ 1 error 

Correcto:

class Main { public static void main (String[] args) { try{ System.out.println(4/0); }catch(ArithmeticException e) { System.out.println("ArithmeticException : divide by 0"); }catch(Exception e) { System.out.println("Exception : divide by 0"); } }
}

Salida:

excepción aritmética: dividir por 0

Prueba anidada de Java

Cuando hay otro bloque de prueba dentro del bloque de prueba:

class Main { public static void main (String[] args) { try{ try{ int[] a={1,2,3}; System.out.println(a[3]); } catch(ArrayIndexOutOfBoundsException e) { System.out.println("Out of bounds"); } System.out.println(4/0); } catch(ArithmeticException e) { System.out.println("ArithmeticException : divide by 0"); } } }

Salida:

Fuera de los límites ArithmeticException: dividir por 0 

Nota: si colocamos el código del intento externo antes del intento interno, si se produce una excepción, ignorará todo el intento interno y pasará directamente a su bloque catch.

class Main { public static void main (String[] args) { try{ System.out.println(4/0); try{ int[] a={1,2,3}; System.out.println(a[3]); } catch(ArrayIndexOutOfBoundsException e) { System.out.println("Out of bounds"); } } catch(ArithmeticException e) { System.out.println("ArithmeticException : divide by 0"); } } }

Salida:

excepción aritmética: dividir por 0

Java finalmente bloque

Contiene código que debe ejecutarse sin importar si se lanza una excepción o no. Contiene código de liberación de archivos, cierre de conexiones, etc.

class Main { public static void main (String[] args) { try{ System.out.println(4/0); }catch(Exception e) { System.out.println(e); } finally { System.out.println("finally executed"); } System.out.println("end"); }
}

Salida:

java.lang.ArithmeticException: / por cero finalmente ejecutado fin 

Finalmente, se ejecutará incluso cuando no manejemos excepciones. Antes de detener el programa, JVM verifica si hay un bloque "finalmente".

class Main { public static void main (String[] args) { try{ System.out.println(4/0); }finally { System.out.println("cleaning......."); } }
} 

Error de tiempo de ejecución:

 Excepción en el subproceso "main" java.lang.ArithmeticException: / por cero en Main.main(File.java:4) 

Salida:

limpieza.......

Java Final vs Finalmente vs Finalizar

Palabra clave de lanzamiento de Java

Es una palabra clave que se utiliza para lanzar explícitamente una excepción.

Podemos usar throw donde, según nuestra lógica, debería ocurrir una excepción.

Ejemplo:

public class ExceptionDemo { static void canVote(int age){ if(age<18) try{ throw new Exception(); }catch(Exception e){ System.out.println("you are not an adult!"); } else System.out.println("you can vote!"); } public static void main (String[] args) { canVote(20); canVote(10); }
} 

Salida:

puedes votar! no eres un adulto! 

Java lanza palabra clave

• La palabra clave throws se usa cuando el receptor de la llamada no quiere manejar la excepción, sino que quiere extender esta responsabilidad de manejar la excepción a la persona que llama a la función.
• Básicamente dice qué tipo de excepción puede lanzar el código y confía en que la persona que llama lo maneje.
• Se usa para manejar las excepciones marcadas, ya que el compilador no permitirá que se compile el código hasta que se manejen.

Ejemplo:

public class ExceptionDemo { static void func(int a) throws Exception{ System.out.println(10/a); } public static void main (String[] args) { try{ func(10); func(0); }catch(Exception e){ System.out.println("can't divide by zero"); } }
}

Salida:

1 no puede dividir por cero 

Si el receptor de la llamada puede lanzar varias excepciones, todas se lanzarán simultáneamente.

import java.util.*; public class ExceptionDemo { static void func(int a,int b) throws ArithmeticException, ArrayIndexOutOfBoundsException{ System.out.println(10/a); int[] arr={1,2,3}; System.out.println(arr[b]); } public static void main (String[] args) { Scanner in=new Scanner(System.in); for(int i=0;i<3;i++){ try{ func(in.nextInt(),in.nextInt()); }catch(ArithmeticException e){ System.out.println("can't divide by zero"); }catch(ArrayIndexOutOfBoundsException e){ System.out.println("Out of bounds!"); } } } }

Entrada:

2 1 0 1 2 3 

Salida:

5 2 no se puede dividir por cero 5 ¡Fuera de los límites! 

Lanzamiento de Java vs lanzamientos

Excepción personalizada de Java

Puede crear su propia excepción e implementar cómo debería comportarse. Su excepción se comportará como la clase de excepción de un niño.

Sintaxis:

 class YourException extends Exception{}

• Ejemplo:
  • digamos que estás trabajando con una compañía aérea 
  • Está en el departamento de facturación de equipaje y, según las normas, puede permitir 15 kg por cliente.
  • Así que ahora más de 15 kg de peso es una condición anormal para nosotros o, en otras palabras, es una excepción.
  • Esta es nuestra excepción basada en lógica, por lo que crearemos nuestra excepción personalizada WeightLimitExceeded 
  • Según la sintaxis, extenderá Exception.
  • Definimos el constructor que se invocará tan pronto como se produzca una excepción.
  • Tenemos que lanzar explícitamente la excepción y, por lo tanto, usaremos la palabra clave throw para eso.
  • El uso de la palabra clave throws es según nuestra necesidad. Si estamos manejando una excepción donde se lanza, entonces podemos evitar los lanzamientos, de lo contrario, usaremos los lanzamientos y lo manejaremos en la persona que llama.

Implementación:

import java.util.*; class WeightLimitExceeded extends Exception{ WeightLimitExceeded(int x){ System.out.print(Math.abs(15-x)+" kg : "); }
} class Main { void validWeight(int weight) throws WeightLimitExceeded{ if(weight>15) throw new WeightLimitExceeded(weight); else System.out.println("You are ready to fly!"); } public static void main (String[] args) { Main ob=new Main(); Scanner in=new Scanner(System.in); for(int i=0;i<2;i++){ try{ ob.validWeight(in.nextInt()); }catch(WeightLimitExceeded e){ System.out.println(e); } } }
}

Entrada:

20 7 

Salida:

5 kg : WeightLimitExceeded ¡Estás listo para volar! 

Manejo de excepciones en Java con anulación de métodos

El manejo de excepciones en Java con anulación de métodos es un método anulado que declara lanzar una excepción y declara que puede lanzar la misma excepción o subtipo de esa excepción.

Para manejar la excepción en Java, deberá seguir tres reglas importantes. Se representan en la siguiente figura.

Ventajas y desventajas del manejo de excepciones en Java

Ventajas de exceptuar el manejo en java 

• Separación del código de manejo de errores del código "regular"
• Propagación de errores en la pila de llamadas
• Agrupación y diferenciación de tipos de errores

Desventajas de exceptuar el manejo en Java 

• Experimentar gastos generales innecesarios
• No entender cómo funciona realmente la aplicación
• Llenar sus registros con eventos ruidosos
• Incapacidad para concentrarse en lo que realmente importa

Esto nos lleva al final de este artículo sobre el manejo de excepciones en Java. Esperamos que ahora tenga claro el concepto de manejo de excepciones en java. Si desea saber más sobre el lenguaje de programación java, inicie sesión en nuestro curso java en linea con certificado y poder avanzar en su carrera.

También mira:

• Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
• PlatoData.Network Vertical Generativo Ai. Empodérate. Accede Aquí.
• PlatoAiStream. Inteligencia Web3. Conocimiento amplificado. Accede Aquí.
• PlatoESG. Automoción / vehículos eléctricos, Carbón, tecnología limpia, Energía, Ambiente, Solar, Gestión de residuos. Accede Aquí.
• Desplazamientos de bloque. Modernización de la propiedad de compensaciones ambientales. Accede Aquí.
• Fuente: https://www.mygreatlearning.com/blog/exception-handling-in-java/