Programa Java para manejar dividir por cero y múltiples excepciones

Excepciones Son los eventos que ocurren debido a un error del programador o error de la máquina que provoca una perturbación en el flujo normal de ejecución del programa.

Manejo de múltiples excepciones: Hay dos métodos para manejar múltiples excepciones en Java.

1. El uso de una declaración de prueba de bloque Try-catch único le permite definir un bloque de código para probar los errores, y podemos dar objetos de excepción al catch blow porque todas las excepciones son heredadas por la clase Exception.
2. El segundo método es crear bloques catch individuales para el controlador de excepciones diferente.

Jerarquía de las excepciones:

Dividir por cero: este programa arroja una excepción aritmética debido a que cualquier número dividido por 0 no está definido en matemáticas. 

// Java Program to Handle Divide By Zero Exception
import java.io.*;
class GFG {
    public static void main(String[] args)
    {
        int a = 6;
        int b = 0;
        System.out.print(a / b);
        // this line Throw  ArithmeticException: / by zero
    }
}

Producción:

Manejo de la excepción Dividir por cero: Uso del bloque try-Catch 

// Java Program to Handle Divide By Zero Exception
import java.io.*;
class GFG {
    public static void main(String[] args)
    {
        int a = 5;
        int b = 0;
        try {
            System.out.println(a / b); // throw Exception
        }
        catch (ArithmeticException e) {
            // Exception handler
            System.out.println(
                "Divided by zero operation cannot possible");
        }
    }
}

Producción:

Múltiples excepciones (ArithmeticException y IndexoutOfBound Exception)

1. Combinación de dos Excepción usando el | El operador está permitido en Java.
2. Tan pronto como ocurre la primera excepción, se lanza en el bloque catch.
3. La verificación de la expresión se realiza mediante la regla de verificación del compilador de precedencia de derecha a izquierda de la expresión.

// Java Program to Handle multiple exception
import java.io.*;
 
class GFG {
    public static void main(String[] args)
    {
        try {
            int number[] = new int[10];
            number[10] = 30 / 0;
        }
        catch (ArithmeticException e) {
            System.out.println(
                "Zero cannot divide any number");
        }
        catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(
                "Index out of size of the array");
        }
    }
}

Producción:

Explicación: aquí se produce una combinación de ArrayIndexOutOfBounds y una excepción aritmética, pero solo se lanza una excepción aritmética, ¿por qué?

De acuerdo con el número de verificación del compilador de precedencia [10] = 30/0 de derecha a izquierda. Es por eso que 30/0 para lanzar el objeto ArithmeticException y el controlador de esta excepción ejecuta Zero no puede dividir ningún número.

Otro método de excepción múltiple: podemos combinar dos excepciones usando el | operador y cualquiera de ellos se ejecuta de acuerdo con la excepción que se produzca.

// Java Program to Handle multiple exception
import java.io.*;
 
class GFG {
    public static void main(String[] args)
    {
        try {
            int number[] = new int[20];
            number[21] = 30 / 9;
            // this statement will throw
            // ArrayIndexOutOfBoundsException e
        }
        catch (ArrayIndexOutOfBoundsException
               | ArithmeticException e) {
            System.out.println(e.getMessage());
            // print the message
        }
    }
}

Producción: