Menu

Experimente, pegue, finalmente e jogue Java com exemplos

try catch finally

Experimente Nosso Instrumento Para Eliminar Problemas

Neste tutorial, discutiremos várias palavras-chave usadas em Java para manipulação de exceções, como Try, Catch, Ends, Throw e Throws com exemplos:

Em nossos tutoriais anteriores, vimos os fundamentos do tratamento de exceções em Java, juntamente com as várias exceções suportadas pela classe Java Exception. Também discutimos a NullPointerException em detalhes.

Podemos incluir exceções em nosso programa usando certas palavras-chave fornecidas em Java. Essas palavras-chave definem vários blocos de código que facilitam a definição e tratamento de exceções.

=> Visite aqui a série exclusiva de tutoriais de treinamento em Java.

Java Tente, pegue finalmente e jogue

O que você aprenderá:

Experimente, pegue e finalmente em Java

As palavras-chave abaixo são usadas em Java para tratamento de exceções.

  • Tentar
  • Pegar
  • Finalmente
  • Lançar
  • Lança

A tabela a seguir descreve resumidamente essas palavras-chave.

Palavra-chaveDescrição
Tentar Especificamos o bloco de código que pode dar origem à exceção em um bloco especial com uma palavra-chave “Try”.
Pegar Quando a exceção é levantada, ela precisa ser capturada pelo programa. Isso é feito usando uma palavra-chave “catch”. Portanto, um bloco catch segue o bloco try que levanta uma exceção. A palavra-chave catch deve sempre ser usada com uma tentativa.
Finalmente Às vezes, temos um código importante em nosso programa que precisa ser executado independentemente de a exceção ser lançada ou não. Este código é colocado em um bloco especial começando com a palavra-chave “Finalmente”. O bloco Finalmente segue o bloco Try-catch.
Lançar A palavra-chave “lançar” é usada para lançar a exceção explicitamente.
Lança A palavra-chave “Throws” não lança uma exceção, mas é usada para declarar exceções. Esta palavra-chave é usada para indicar que uma exceção pode ocorrer no programa ou método.

Neste tutorial, discutiremos todas as palavras-chave acima em detalhes, juntamente com os exemplos de programação.

Experimente o Bloco em Java

Sempre que estamos escrevendo um programa, pode haver um código que suspeitamos que pode gerar uma exceção. Por exemplo, podemos suspeitar que pode haver uma operação de “divisão por zero” no código que lançará uma exceção.

Este código que pode gerar uma exceção é colocado em um bloco com a palavra-chave “try”. Portanto, o bloco try contém o código ou conjunto de instruções que podem gerar uma exceção.

A sintaxe geral do bloco try é a seguinte:

try{ //set of statements that can raise exception }

Conseqüentemente, se um programador pensa que certas instruções irão gerar exceções, coloque essas instruções em um bloco try. Observe que, quando ocorre uma exceção em uma instrução específica em um bloco try, o restante do código não é executado.

Quando ocorre uma exceção em um bloco try em uma instrução específica, o controle sai e o programa termina abruptamente. Para evitar esse encerramento abrupto do programa, devemos “lidar” com essa exceção. Esse tratamento é feito usando a palavra-chave “catch”. Portanto, um bloco try sempre tem um bloco catch o seguindo.

Catch Block In Java

Usamos um bloco catch para lidar com exceções. Este é o bloco com a palavra-chave “catch”. O bloco catch segue o bloco try.

Sempre que ocorre uma exceção no bloco try, o código no bloco catch que corresponde à exceção é executado.

A sintaxe geral do bloco catch é:

catch (Exception e){ //code to handle exception e }

Geralmente, a exceção declarada deve ser a classe pai de todas as exceções, ou seja, Exceção. Mas se houver mais de uma exceção, também podemos escrever tipos de exceção específicos ou exceções geradas.

A seguir, discutiremos o bloco try-catch. Observe que, para cada bloco try, podemos ter vários blocos catch.

Try-Catch Java

A sintaxe geral do bloco try-catch é mostrada abaixo:

try{ //code causing exception } catch (exception (exception_type) e (object)) { //exception handling code }

O bloco try pode ter várias linhas de código que podem gerar várias exceções. Cada uma dessas exceções é tratada por um bloco catch independente.

O tratador de exceção genérico, objeto e da classe Exception pode tratar todas as exceções, mas se quisermos tratar exceções específicas, então é aconselhável especificar o tratador de exceção genérico como o último bloco catch.

Java Try Catch Example

Agora vamos demonstrar um bloco try-catch em Java. Aqui no bloco try, definimos uma operação de divisão. O divisor é zero. Portanto, a declaração que divide os dois números levanta uma exceção aritmética. Temos um bloco catch que define um manipulador para exceção aritmética.

Abaixo está um exemplo de programa Java.

class Main { public static void main(String args()) { int val1, val2; try { //this block will contain statements that may raise exceptions System.out.println('Try Block:: Start'); val1 = 0; val2 = 25 / val1; System.out.println(val2); System.out.println('Try Block:: End'); } catch (ArithmeticException e) { //handler for ArithmeticException System.out.println('ArithmeticException :: Divide by Zero!!'); } System.out.println('Outside try-catch:: Rest of the code.'); } }

Resultado

Experimente o exemplo de bloco

gateway padrão não encontrado windows 10

Captura de múltiplas exceções

Conforme já mencionado, um bloco try pode conter um código que gera mais de uma exceção. Nesse caso, precisaremos de mais de um bloco catch para tratar cada exceção. Um único bloco try pode ser seguido por vários blocos catch. Cada bloco catch tratará as exceções independentes.

No caso de vários blocos catch, temos que lembrar os pontos abaixo:

  • Em um programa Java, em qualquer momento, apenas uma exceção pode ocorrer. Além disso, em qualquer ponto, apenas um bloco catch é executado.
  • Os vários blocos catch devem ser ordenados de forma que o bloco catch para a exceção mais específica venha primeiro e depois o geral.

Por exemplo, se tivermos ArithmeticException e General Exception, o bloco catch que manipula ArithmeticException virá primeiro, seguido pelo catch block que manipula Exception.

O exemplo a seguir demonstra vários blocos catch.

public class Main { public static void main(String() args) { //try block containing exception prone code try{ System.out.println('try Block:: Begin'); int myArray()=new int(5); myArray (5)=10/0; } //multiple catch blocks catch(ArithmeticException e) { System.out.println('Arithmetic Exception :: Divide by zero!!'); } catch(ArrayIndexOutOfBoundsException e) { System.out.println('ArrayIndexOutOfBounds :: Accessed index out of bounds'); } catch(Exception e) { System.out.println('Exception :: ' + e.getMessage ()); } System.out.println('rest of the code'); } }

Resultado

Exceção Aritmética

No programa acima, um ArithmeticException capturado no primeiro bloco catch é gerado. Se este bloco catch não foi especificado, a exceção teria se propagado para o bloco catch generalizado.

Vamos modificar ligeiramente o programa acima para que o bloco try levante duas exceções. Agora vamos ver o resultado.

public class Main { public static void main(String() args) { //try block containing exception prone code try{ System.out.println('try Block:: Begin'); int myArray()=new int(5); System.out.println('Array element 10 : ' + myArray(10)); myArray(5)=10/0; } //multiple catch blocks catch(ArithmeticException e) { System.out.println('Arithmetic Exception :: Divide by zero!!'); } catch(ArrayIndexOutOfBoundsException e) { System.out.println('ArrayIndexOutOfBounds :: Accessed index out of bounds'); } catch(Exception e) { System.out.println('Exception :: ' + e.getMessage ()); } System.out.println('rest of the code'); } }

Resultado

Tratamento de múltiplas exceções

Se virmos essa saída, ela mostra ArrayIndexOutOfBoundsException sendo lançada. Isso ocorre porque a instrução que gera ArrayIndexOutOfBoundsException é executada primeiro. A exceção é lançada e o controle vai para o bloco catch correspondente.

Try-Catch Aninhado

Um bloco try dentro de outro bloco try é chamado de bloco try aninhado. Precisamos de tais estruturas em certas situações, quando um trecho de código contido em um código try pode ser tal que algumas linhas geram certas exceções e outro trecho de código gera uma exceção completamente diferente.

No caso de blocos try aninhados, primeiro, o bloco try interno é executado e a exceção é tratada. Se o bloco try mais interno não tiver um bloco catch correspondente, ele será propagado um nível até seu bloco try pai. Desta forma, a exceção é propagada para cima até que o manipulador de exceção correspondente seja encontrado.

Se não houver um manipulador de exceção correspondente à exceção, o programa será encerrado abruptamente com uma mensagem gerada pelo sistema.

A sintaxe geral de um bloco try aninhado é fornecida abaixo:

try { //try_block 1; try { //try_block 2; } catch(Exception e) { //exception handler code } } catch(Exception e) { //exception handler code }

Vamos implementar um programa para demonstrar o bloco try-catch aninhado.

class Main{ public static void main(String args()){ //Main try block try{ //try block1 try{ System.out.println('Try Block1'); int num =15/0; System.out.println(num); } catch(ArithmeticException e1){ System.out.println('Block1 Exception: e1'); } //try block2 try{ System.out.println('Try Block2'); int num =100/0; System.out.println(num); } catch(ArrayIndexOutOfBoundsException e2){ System.out.println('Block2 Exception: e2'); } System.out.println('General statement after Block1 and Block2'); } catch(ArithmeticException e3){ System.out.println('Main Block Arithmetic Exception'); } catch(ArrayIndexOutOfBoundsException e4){ System.out.println('Main Block ArrayIndexOutOfBoundsException'); } catch(Exception e5){ System.out.println('Main Block General Exception'); } System.out.println('Code after Nested Try Block'); } }

Resultado

Try-catch aninhado em Java

No programa acima, temos dois blocos try incluídos no bloco try principal. Ambos os blocos try internos têm um código que gera ArithmeticException. Mas fornecemos um bloco catch correspondente apenas para o primeiro bloco e não para o segundo bloco try.

Conseqüentemente, o segundo bloco propaga sua exceção para o bloco try principal e então a trata. Isso fica evidente na saída.

Finalmente bloco em Java

Até agora, vimos o bloco try-catch e o bloco try aninhado. Sabemos que o código que deve gerar a exceção é colocado em um bloco try. Quando ocorre uma exceção, o restante do código no bloco try não é executado.

O programa termina abruptamente se uma exceção não for tratada ou se o controle for passado para o tratador de exceção.

Em tal situação, surge a necessidade de incluir um código que deve ser executado independentemente de ocorrer uma exceção ou não. Isso significa que executaremos um trecho de código mesmo quando ocorrer uma exceção e também quando a exceção não ocorrer.

Mas como o bloco try sai após a exceção ser levantada, não podemos colocar este código no bloco try. Da mesma forma, o bloco catch tem um manipulador de exceção, portanto, não podemos colocá-lo no bloco catch também.

Portanto, precisamos de um bloco separado que contenha um código que seja executado independentemente da ocorrência ou não de uma exceção. Java fornece um bloco “finalmente” que contém esse trecho de código.

Portanto, um bloco finally em Java pode conter instruções críticas que devem ser executadas no programa. A execução dessas instruções deve ser realizada mesmo quando ocorre uma exceção ou não.

Portanto, colocaremos códigos como conexões de fechamento, objetos de fluxo, etc. ou qualquer código de limpeza no bloco finally para que possam ser executados mesmo se ocorrer uma exceção.

O bloco finally em Java geralmente é colocado após um bloco try ou catch. Observe que o bloco finally não pode existir sem um bloco try. Quando o bloco finally é incluído com try-catch, ele se torna um “ tentar pegar finalmente ' quadra.

Podemos pular o bloco finally no código de tratamento de exceções. Isso significa que o bloco finally é opcional.

Se o bloco try não gerar nenhuma exceção, o bloco finally será executado após o bloco try. Se houver uma exceção no bloco try, o controle passará primeiro para o bloco catch e depois para o bloco finally.

Uma exceção ocorrendo no bloco finally se comporta da mesma maneira que qualquer outra exceção. Mesmo se o bloco try contiver a instrução return ou instruções de ramificação como break e continue, o bloco finally ainda será executado.

Mantendo esses pontos em mente, vamos em frente com a sintaxe geral e exemplos do bloco finally.

A sintaxe geral do bloco finally é a seguinte:

try { //code that might raise exception }catch { //code that handles exception }finally { //mandatory code to be executed }

Embora o bloco final seja sempre executado, há certas situações ou casos em que ele não é executado.

Estes são os casos abaixo:

  • Quando o tópico está morto.
  • Quando o método System.exit () é usado.
  • Quando ocorre uma exceção no bloco finally.

Vamos implementar alguns programas para demonstrar o bloco finally.

class Main { public static void main (String args()) { //try block try { System.out.println ('::Try Block::'); int data = 125 / 5; System.out.println ('Result:' + data); } //catch block catch (NullPointerException e) { System.out.println ('::Catch Block::'); System.out.println (e); } //finally block finally { System.out.println (':: Finally Block::'); System.out.println ('No Exception::finally block executed'); } System.out.println ('rest of the code...'); } }

Resultado

Finalmente Bloco - Saída

melhor programa para se livrar de malware

O programa acima mostra um bloco try-catch-finally. No bloco try, uma operação válida é executada e, portanto, nenhuma exceção é lançada. Portanto, o controle não é passado para captura de tentativa, mas para bloqueio final.

O programa a seguir é outro exemplo de bloco try-catch-finally, mas, neste caso, a exceção é lançada no bloco try quando executamos uma operação de divisão por zero. Assim, o bloco finally é executado após a tentativa de execução do bloco catch.

class Main { public static void main(String args()) { //try block try{ System.out.println('::Try block::'); int num=67/0; System.out.println(num); } //catch block catch(ArithmeticException e){ System.out.println('::Catch block::'); System.out.println('ArithmeticException::Number divided by zero'); } //finally block finally{ System.out.println('::Finally block::'); } System.out.println('Rest of the code continues...'); } }

Resultado

saída - bloco de teste dividido por zero

Lance uma exceção em Java

Java fornece uma palavra-chave “throw” com a qual podemos lançar explicitamente as exceções no código. Por exemplo, se estivermos verificando operações aritméticas e quisermos levantar algumas exceções após verificar operandos, podemos fazer isso usando a palavra-chave ‘throw’.

Usando a palavra-chave throw, podemos lançar as exceções verificadas ou não verificadas. A palavra-chave throw também é usada para lançar exceções personalizadas.

A sintaxe geral da palavra-chave throw é:

throw exception; or throw new exception_class('error message');

A seguir está um programa de exemplo para demonstrar a palavra-chave throw.

public class Main{ static void validate_Age(int age){ //if specified age is <18, throw ArithmeticException if(age<18) throw new ArithmeticException('Not eligible to vote and drive!!'); else //print the message System.out.println('Eligible to vote and drive!!'); } public static void main(String args()){ //call validate_Age method validate_Age(10); System.out.println('rest of the code...'); } }

Resultado

votar e dirigir

No programa acima, usamos um método para validar a idade. Se a idade for<18, then an exception is thrown to indicate the age is not valid.

Cláusula de lançamento

Vimos o bloco try para declarar exceções. Ele contém o código que pode gerar exceções. Existe outra maneira de declarar uma exceção e é usando a palavra-chave “throws”.

A declaração de exceção usando a palavra-chave “throws” informa ao programador que pode haver uma exceção especificada após a palavra-chave “throws” e o programador deve fornecer o código do manipulador correspondente para essa exceção para manter o fluxo normal do programa.

No entanto, surge a questão de por que precisamos de uma palavra-chave “throws” quando temos um bloco try-catch mais confiável para declarar e tratar exceções?

Um dos motivos é que, à medida que aumenta o número de exceções que podem ocorrer, o número de blocos catch que trata as exceções também aumenta, pois um bloco catch pode tratar apenas uma exceção.

Da mesma forma, se houver muitos métodos em um programa e cada método tiver várias exceções, o código se tornará desnecessariamente longo e difícil de gerenciar.

Portanto, declarar uma exceção com a palavra-chave throws na assinatura do método e, em seguida, manipular a chamada do método usando try-catch parece ser uma solução viável.

Outra vantagem de declarar exceções usando a palavra-chave throws é que somos forçados a lidar com as exceções. Se não fornecermos um manipulador para uma exceção declarada, o programa gerará um erro.

A sintaxe geral da palavra-chave throws é a seguinte:

return_type method_name() throws exception_class_name{ //method code }

Vamos agora implementar um programa Java para demonstrar a palavra-chave “throws”.

Neste programa, temos uma classe Example_throw na qual temos um método testMethod. Na assinatura deste testMethod, declaramos duas exceções IOException e Arithmetic Exception usando a palavra-chave throws. Então, na função principal, as exceções lançadas são tratadas pelo bloco catch.

import java.io.*; class Example_Throw { //declare exception using throws in the method signature void testMethod(int num) throws IOException, ArithmeticException{ if(num==1) throw new IOException('IOException Occurred'); else throw new ArithmeticException('ArithmeticException'); } }class Main{ public static void main(String args()){ try{ //this try block calls the above method so handle the exception Example_Throw obj=new Example_Throw(); obj.testMethod(1); }catch(Exception ex){ System.out.println(ex); } } }

Resultado

java.io.IOException

perguntas frequentes

Q # 1) Quando usar throws throw VS try-catch em Java?

Responda: A palavra-chave “throws” é usada para declarar a exceção com a assinatura do método. A palavra-chave throw é usada para lançar explicitamente a exceção. O bloco try-catch é usado para tratar as exceções lançadas por outros.

P # 2) Podemos usar arremessos, tentar e pegar em um único método?

Responda: Não. Você não pode lançar a exceção e também capturá-la no mesmo método. A exceção que é declarada usando throws deve ser tratada no método de chamada que chama o método que lançou a exceção.

P # 3) O que acontece quando um bloco catch lança uma exceção?

Responda: Quando uma exceção é lançada no bloco catch, o programa irá parar a execução. No caso de o programa ter que continuar, então deve haver um bloco try-catch separado para tratar a exceção levantada no bloco catch.

P # 4) O que é try-catch-finally em Java?

Responda: O bloco try-catch-finally contém os três blocos, ou seja, o bloco try, o bloco catch e o bloco finally.

O bloco Try contém o código que pode lançar uma exceção. O bloco Catch contém o manipulador de exceção para exceções no bloco try. O bloco finally contém o código crítico que será executado independentemente de a exceção ter ocorrido ou não.

P # 5) Posso finalmente bloquear o try-catch?

Responda: Sim, se tivermos um código de limpeza que possa lançar uma exceção no bloco finally, podemos ter um bloco try-catch. No entanto, parece feio.

Conclusão

Neste tutorial, discutimos as várias palavras-chave usadas no tratamento de exceções em Java. Discutimos palavras-chave como tentar, pegar, finalmente, lançar e arremessar.

O código que possivelmente lançará uma exceção é colocado no bloco try e catch fornece o manipulador para a exceção. O bloco finally executa o código contido nele, independentemente de a exceção ser lançada ou não. O bloco finally geralmente segue o bloco try ou try-catch.

Usamos a palavra-chave throws para declarar exceções com a assinatura do método e throw é usado explicitamente para lançar exceções. Normalmente usamos a palavra-chave throw para lançar exceções personalizadas.

=> Confira o guia de treinamento Java perfeito aqui.

Leitura recomendada

^