¿Cuál es la diferencia entre throw e y throw new Exception(e) en el bloque catch de Java?

Exception (excepción) es un problema que ocurre durante la ejecución del programa (error de tiempo de ejecución). Aquí hay algunos ejemplos de soluciones-

• si el tamaño de su array es10si una línea de código intenta acceder al elemento11elementos.

• Si intenta dividir un número por cero (el resultado es infinito y el JVM no sabe cómo calcular su valor).

Cuando ocurre una excepción, el programa se detiene repentinamente en la línea que causó la excepción, lo que impide que el resto del programa se ejecute. Para evitar esto, debe manejar las excepciones.

En Java hay dos tipos de excepciones.

• Excepciones no comprobadas - Las excepciones no comprobadas son las que ocurren en tiempo de ejecución. Estas también se conocen como excepciones de tiempo de ejecución. Incluyen errores de programación, como errores lógicos o mal uso de API. Las excepciones de tiempo de ejecución se ignoran en tiempo de compilación.

• Excepciones comprobadas - Las excepciones comprobadas ocurren en tiempo de compilación y también se conocen como excepciones de tiempo de compilación. Estas excepciones no se pueden ignorar simplemente en tiempo de compilación. Los programadores deben prestar atención (manejar) estas excepciones.

Manejo de excepciones

Para manejar excepciones, Java proporciona try-Mecanismo de bloque catch

Se coloca un try alrededor del código que puede generar excepciones. / Bloque catch. try / El código dentro del bloque catch se llama código protegido.

Sintaxis

try {
　　　//　Código protegido
} catch (ExceptionName e1) {
　　　//　Bloque catch
}

Cuando una excepción se lanza dentro del bloque try, el JVM almacena los detalles de la excepción en la pila de excepciones y continúa procesando el bloque catch, en lugar de finalizar el programa.

La declaración catch implica declarar el tipo de excepción que desea capturar. Si ocurre una excepción en el bloque try, se verificará el bloque catch después del try.

Si se lista el tipo de excepción ocurrida en el bloque catch, se transmite la excepción al bloque catch de la misma manera que se pasan parámetros a los parámetros del método.

Ejemplo

import java.io.File;
import java.io.FileInputStream;
public class Test {
　　　public static void main(String args[]){
　　　　　　System.out.println("Hello");
　　　　　　try{
　　　　　　　　　File file = new File("my_file");
　　　　　　　　　FileInputStream fis = new FileInputStream(file);
　　　　　　catch(Exception e){
　　　　　　　　　System.out.println("No se encontró la ruta del archivo especificado");
　　　　　　}
　　　}
}

Resultado de salida

No se encontró la ruta del archivo especificado

Rethrowear excepción

Al almacenar una excepción en un bloque catch, puede rethrowearla usando la palabra clave throw (usada para lanzar un objeto de excepción).

Al rethrowear una excepción, puede lanzar la misma excepción sin ajustarla-

try {
　　　int result = (arr[a])/(arr[b]);
　　　System.out.println("Result ",+arr[a]+"/"+arr[b]+":+result);
}catch(ArithmeticException e) {
　　　lanzar e;
}

O, encapsúlela en una nueva excepción y lanzarla. Cuando encapsula una excepción en otra y la lanza, se llama a esto excepción enlazada o encapsulada, y al hacerlo, puede ajustar su excepción lanzando una excepción de nivel superior más abstracta.

try {
　　　int result = (arr[a])/(arr[b]);
　　　System.out.println("Result ",+arr[a]+"/"+arr[b]+":+result);
}catch(ArrayIndexOutOfBoundsException e) {
　　　lanzar new IndexOutOfBoundsException();
}

Ejemplo

En el siguiente ejemplo Java, el código dentro de demoMethod() podría lanzar ArrayIndexOutOfBoundsException y ArithmeticException. Capturamos estas dos excepciones en dos bloques catch diferentes.

En el bloque catch, lanzamos dos excepciones encapsuladas en una excepción más alta, y la otra se lanza directamente.

import java.util.Arrays;
import java.util.Scanner;
public class RethrowExample {
　　　public void demoMethod() {
　　　　　　Scanner sc = new Scanner(System.in);
　　　　　　int[] arr = {10,　20,　30,　2, 0,　8};
　　　　　　System.out.println("Array: ",+Arrays.toString(arr));
　　　　　　System.out.println("Choose numerator and denominator (not 0) from this array (enter positions 0 to　5);
　　　　　　int a = sc.nextInt();
　　　　　　int b = sc.nextInt();
　　　　　　try {
　　　　　　　　　int result = (arr[a])/(arr[b]);
　　　　　　　　　System.out.println("Result ",+arr[a]+"/"+arr[b]+":+result);
　　　　　　}catch(ArrayIndexOutOfBoundsException e) {
　　　　　　　　　lanzar new IndexOutOfBoundsException();
　　　　　　}catch(ArithmeticException e) {
　　　　　　　　　lanzar e;
　　　　　　}
　　　}
　　　public static void main(String [] args) {
　　　　　　new RethrowExample().demoMethod();
　　　}
}

Resultado de salida

Array:  [10,　20,　30,　2, 0,　8]
Elija el numerador y el denominador (no 0) de este array (ingrese posiciones 0 a　5)
0
4
Excepción en el hilo "main" java.lang.ArithmeticException:　/　por cero
　　　at miPaquete.RethrowExample.demoMethod(RethrowExample.java:16)
　　　at miPaquete.RethrowExample.main(RethrowExample.java:25)

Resultado de salida

Array:  [10,　20,　30,　2, 0,　8]
Elija el numerador y el denominador (no 0) de este array (ingrese posiciones 0 a　5)
124
5
Excepción en el hilo "main" java.lang.IndexOutOfBoundsException
　　　at miPaquete.RethrowExample.demoMethod(RethrowExample.java:17)
　　　at miPaquete.RethrowExample.main(RethrowExample.java:23)