Requisito previo: bloque Try-Catch en Java
En Java, es posible que su programa encuentre excepciones, para las cuales el lenguaje proporciona declaraciones try-catch para manejarlas. Sin embargo, existe la posibilidad de que el fragmento de código encerrado dentro del bloque ‘try’ sea vulnerable a más de una excepción. Por ejemplo, eche un vistazo al siguiente código de ejemplo:
// A sample Java code with a try catch block
// where the try block has only one catch block
// to handle all possible exceptions
// importing class Random to generate a random number as input
import java.util.Random;
class A {
void func(int n)
{
try {
// this will throw ArithmeticException if n is 0
int x = 10 / n;
int y[] = new int[n];
// this will throw ArrayIndexOutOfBoundsException
// if the value of x surpasses
// the highest index of this array
y[x] = 10;
}
catch (Exception e) {
System.out.println("Exception occurred");
}
}
public static void main(String a[])
{
new A().func(new Random().nextInt(10));
}
}
Salida en caso de cualquiera de las excepciones :
Exception occurred
Como puede ver en el código anterior, existe la posibilidad de que ocurra cualquiera de las dos excepciones mencionadas anteriormente. Para manejarlos a ambos, la declaración catch acepta cualquier excepción que pueda ocurrir al pasar una referencia a la clase Exception, que es el padre de todas las clases de excepción. Sin embargo, esta instrucción catch hace lo mismo para todos los tipos de excepciones.
Especificar acciones personalizadas para diferentes excepciones
Para especificar acciones personalizadas en tales casos, los programadores generalmente colocan varias instrucciones catch, como en el siguiente ejemplo:
// A sample Java code with one try block
// having multiple catch blocks to catch
// different exceptions
// importing class Random to generate a random number as input
import java.util.Random;
class A {
void func(int n)
{
try {
// this will throw ArithmeticException if n is 0
int x = 10 / n;
int y[] = new int[n];
// this will throw ArrayIndexOutOfBoundsException
// if the value of x surpasses
// the highest index of this array
y[x] = 10;
}
catch (ArithmeticException e) {
System.out.println("Dividing by 0");
}
catch (ArrayIndexOutOfBoundsException e) {
System.out.println("That index doesn't exist");
}
}
public static void main(String a[])
{
new A().func(new Random().nextInt(10));
}
}
Salida :
a) In case of ArithmeticException: Dividing by 0 b) In case of ArrayIndexOutOfBoundsException: That index doesn't exist
Especifique acciones personalizadas para diferentes excepciones usando instancia de
Sin embargo, hay una manera de hacer lo mismo usando solo un bloque catch . Para hacerlo, Java proporciona un operador: instancia de .
Al usar este operador, podemos especificar acciones personalizadas para las diferentes excepciones que ocurren. El siguiente programa demuestra cómo:
// Java program to demonstrate the use of
// instanceof to specify different actions for
// different exceptions using only one catch block
// importing class Random to generate a random number as input
import java.util.Random;
class A {
void func(int n)
{
try {
// this will throw ArithmeticException if n is 0
int x = 10 / n;
int y[] = new int[n];
y[x] = 10;
// this will throw ArrayIndexOutOfBoundsException
// if the value of x surpasses
// the highest index of this array
System.out.println("No exception arose");
}
catch (Exception e) {
if (e instanceof ArithmeticException)
System.out.println("Can't divide by 0");
if (e instanceof ArrayIndexOutOfBoundsException)
System.out.println("This index doesn't exist in this array");
}
}
public static void main(String a[])
{
new A().func(new Random().nextInt(10));
}
}
Producción:
a) In case of ArithmeticException: Can't divide by 0 b) In case of ArrayIndexOutOfBoundsException: This index doesn't exist in this array c) In case of no exception: No exception arose
Al usar el operador instanceof en el manejo de excepciones, es fácil lograr el objetivo antes mencionado y, al mismo tiempo, hace que su código sea menos complicado. Una cosa que debe tenerse en cuenta aquí es que tan pronto como el bloque try encuentre una excepción, el control saltará directamente al bloque catch, para manejar, evitando así que se ejecute el resto del cuerpo del bloque try. Como resultado, aunque puede existir la posibilidad de que ocurra más de una excepción, el bloque try solo generará una excepción, antes de cambiar el control al bloque catch.