Para lidar com várias exceções em java, podemos:

• Usar vários blocos catch: Aqui você pode lidar com várias exceções em vários blocos catch para um bloco try correspondente. O fluxo do programa chegará automaticamente ao bloco catch um por um e, em seguida, o bloco catch correspondente será encontrado de acordo com a exceção e será tratado de acordo.
• Use várias instruções Catch em argumentos de um bloco Catch: esse recurso veio do Java 7. Aqui você pode lidar com várias exceções em um único bloco catch (separado por sinal de pipe) para um bloco try correspondente. O fluxo do programa chegará automaticamente ao bloco catch e, em seguida, a exceção correspondente dentro dos argumentos do bloco catch será encontrada para o bloco try e será tratada de acordo.

Múltiplos blocos de captura

Em Java, um único bloco try pode ter vários blocos catch.

Por que precisamos de vários blocos catch em Java?

Múltiplos blocos catch em Java são usados ​​para lidar com diferentes tipos de exceções. Quando as instruções em um único bloco try geram várias exceções, exigimos vários blocos catch para lidar com diferentes tipos de exceções. Este mecanismo é chamado de bloco multi-catch em java .

Um bloco try pode ser seguido por um ou mais blocos catch. Cada bloco catch deve conter um manipulador de exceção diferente. Você pode capturar diferentes exceções em diferentes blocos catch se ele contiver um manipulador de exceção diferente. Quando ocorre uma exceção no bloco try, o bloco catch correspondente que manipula essa exceção específica é executado. Portanto, se você tiver que executar diferentes tarefas na ocorrência de diferentes exceções, poderá usar a captura multitentativa em Java.

Sintaxe

A sintaxe para usar um único try com mais de um bloco catch em java é a seguinte:

try 
{ 
  statements; 
} 
catch(ExceptionType1 e1) 
{ 
  statements; 
} 
catch(ExceptionType2 e2) 
{ 
  statements; 
}

Caso o objeto de exceção lançado não corresponda ao primeiro bloco catch, o segundo bloco catch será verificado e assim por diante.

Por vez, ocorre apenas uma exceção e, por vez, apenas um bloco catch é executado. Todos os blocos catch devem ser arranjados de tal forma que a exceção deve vir da primeira subclasse e depois da superclasse, ou seja, catch para ArithmeticException deve vir antes de catch para Exception.

Fluxograma do Bloco Multi-catch

Exemplos

Exemplo 1

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (ArithmeticException e) {
      System.out.println(e.getMessage());
    } catch (ArrayIndexOutOfBoundsException e) {
      System.out.println(e.getMessage());
    } 
  }
}

/ by zero

• ArithmeticException porque estamos tentando dividir um número por 0.
• ArrayIndexOutOfBoundException porque declaramos uma nova matriz inteira com limites de matriz de 0 a 9 e estamos tentando atribuir um valor ao índice 10.

A associatividade do operador de atribuição = é da direita para a esquerda, então uma ArithmeticException é lançada primeiro com a mensagem / por zero.

Exemplo 2

class Example2{
   public static void main(String args[]){
     try{
         int a[]=new int[7];
         a[4]=30/0;
         System.out.println("First print statement in try block");
     }
     catch(ArithmeticException e){
        System.out.println("Warning: ArithmeticException");
     }
     catch(ArrayIndexOutOfBoundsException e){
        System.out.println("Warning: ArrayIndexOutOfBoundsException");
     }
     catch(Exception e){
        System.out.println("Warning: Some Other exception");
     }
   System.out.println("Out of try-catch block...");
  }
}

Warning: ArithmeticException
Out of try-catch block...

Capturando mais de um tipo de exceção com um manipulador de exceção

No Java 7 e posterior, o bloco catch foi aprimorado para lidar com várias exceções em um único bloco catch . Se você estiver capturando várias exceções e elas tiverem um código semelhante.

Um único bloco catch tem a possibilidade de manipular (capturar) várias exceções, separando cada uma delas com | (símbolo de tubo) no bloco catch .

Esse recurso pode reduzir a duplicação de código e aumentar a eficiência, além de diminuir a tentação de capturar uma exceção excessivamente ampla. O bytecode gerado durante a compilação deste programa será menor do que o programa com vários blocos catch , pois não há redundância de código.

Considere o exemplo a seguir, que contém código duplicado em cada um dos blocos catch :

catch (IOException ex) {
     logger.log(ex);
     ex.printStackTrace();
catch (SQLException ex) {
     logger.log(ex);
     ex.printStackTrace();
}

No Java SE 7 e posterior, podemos eliminar o código duplicado usando esta abordagem

Sintaxe

Na catchcláusula, especifique os tipos de exceções que o bloco pode manipular e separe cada tipo de exceção com uma barra vertical ( |):

try {
  // code
} catch (ExceptionType1 | Exceptiontype2 ex) { 
  // catch block
}

Exemplos

Exemplo 1

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
      System.out.println(e.getMessage());
    }
  }
}

/ by zero

O bytecode gerado durante a compilação deste programa será menor do que o programa com vários blocos catch , pois não há redundância de código.

Observação : se um bloco catch tratar mais de um tipo de exceção, o parâmetro catch será implicitamente final . Neste exemplo, o parâmetro catch ex é final e, portanto, você não pode atribuir nenhum valor a ele dentro do bloco catch .

Essa abordagem geralmente é usada se você estiver capturando várias exceções e elas tiverem código semelhante. mas também podemos usá-lo como quisermos.

Exemplo 2

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (ArithmeticException|ArrayIndexOutOfBoundsException e) {
      if (e instanceof ArithmeticException)
          System.out.println("ArithmeticException");
      else
          System.out.println("ArrayIndexOutOfBoundsException");
    }
  }
}

Ao capturar várias exceções em um único bloco catch , a regra é generalizada para especializada.

Isso significa que, se houver uma hierarquia de exceções no bloco catch , podemos capturar apenas a exceção base em vez de capturar várias exceções especializadas.

Vamos dar um exemplo.

Exemplo 1: Capturando apenas a classe de exceção básica

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (Exception e) {
      System.out.println(e.getMessage());
    }
  }
}

/ by zero

Se a classe de exceção base já tiver sido especificada no bloco catch , não use classes de exceção filhas no mesmo bloco catch . Caso contrário, obteremos um erro de compilação.

Vamos dar um exemplo.

Exemplo 2: Capturando classes de exceção base e filha

class Main {
  public static void main(String[] args) {
    try {
      int array[] = new int[10];
      array[10] = 30 / 0;
    } catch (Exception | ArithmeticException | ArrayIndexOutOfBoundsException e) {
      System.out.println(e.getMessage());
    }
  }
}

Main.java:6: error: Alternatives in a multi-catch statement cannot be related by subclassing

Programa

Em alguns casos, mais de uma exceção pode ser gerada por um único trecho de código. Para lidar com esse tipo de situação, você pode especificar duas ou mais cláusulas catch, cada uma capturando um tipo diferente de exceção. Quando uma exceção é lançada, cada instrução catch é inspecionada em ordem e a primeira cujo tipo corresponde ao da exceção é executada. Depois que uma instrução catch é executada, as outras são ignoradas e a execução continua após o bloco try/catch. O exemplo a seguir captura dois tipos de exceção diferentes:

// Demonstrate multiple catch statements.
class MultiCatch {
public static void main(String args[]) {
try {
    int a = args.length;
    System.out.println("a = " + a);
    int b = 42 / a;
    int c[] = { 1 };
    c[42] = 99;
} catch(ArithmeticException e) {
    System.out.println("Divide by 0: " + e);
} catch(ArrayIndexOutOfBoundsException e) {
    System.out.println("Array index oob: " + e);
}
System.out.println("After try/catch blocks.");
}
}

Aqui está a saída gerada ao executá-lo nos dois sentidos:

C:\>java MultiCatch
a = 0
Divide by 0: java.lang.ArithmeticException: / by zero
After try/catch blocks.
C:\>java MultiCatch TestArg
a = 1
Array index oob: java.lang.ArrayIndexOutOfBoundsException:42
After try/catch blocks.

/* This program contains an error.
A subclass must come before its superclass in
a series of catch statements. If not,
unreachable code will be created and a
compile-time error will result.
*/
class SuperSubCatch {
public static void main(String args[]) {
    try {
        int a = 0;
        int b = 42 / a;
    } catch(Exception e) {
        System.out.println("Generic Exception catch.");
    }
    /* This catch is never reached because
    ArithmeticException is a subclass of Exception. */
    catch(ArithmeticException e) { // ERROR - unreachable
        System.out.println("This is never reached.");
    }
}
}

Junte-se ao Grupo Mouad Oumous Java WhatsApp PARTICIPE

Junte-se ao canal de telegrama Mouad Oumous PARTICIPE

Semáforo | API Simultânea de Java Pacotes de API Simultânea de Java — Parte 1 Java — 8 | Interface BiFunction, BiConsumer e BiPredicate com exemplo