Palavras-chave throw e throws Java

Neste tutorial, aprenderemos a lidar com exceções usando as palavras-chave throw e throws com a ajuda de exemplos.

No Java, as exceções podem ser classificadas em dois tipos:

• Exceções não verificadas:Elas não são verificadas na compilação, mas sim em tempo de execução, por exemplo: ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException, exceções sob a classe Error e outras.

• Exceções a serem verificadas:Verifique-as na compilação. Por exemplo, IOException, InterruptedException e outras.

Por favor, consulteExceções do JavaPara entender melhor as exceções verificadas e não verificadas.

Normalmente, não precisamos lidar com exceções não verificadas. Isso porque exceções não verificadas ocorrem devido a erros de programação. E corrigi-las em vez de lidar com elas é um bom hábito.

Agora, este tutorial se concentrará em como usar throw e throws para lidar com exceções verificadas.

Palavra-chave throws do Java

Usamos a palavra-chave throws na declaração do método para declarar os tipos de exceções que podem ocorrer.

Sua sintaxe é:

accessModifier returnType methodName() throws ExceptionType1, ExceptionType2　... {
　　//　code
}

Da sintaxe acima, podemos ver que usamos throws para declarar várias exceções.

Exemplo1Palavra-chave throws do Java

import java.io.*;
class Main {
　　public static void findFile() throws IOException {
　　　　//Código que pode gerar IOException
　　　　File newFile = new File("test.txt");
　　　　FileInputStream stream = new FileInputStream(newFile);
　　}
　　public static void main(String[] args) {
　　　　try{
　　　　　　findFile();
　　　　} catch(IOException e){
　　　　　　System.out.println(e);
　　　　}
　　}
}

Resultados de Saída

java.io.FileNotFoundException: test.txt (Arquivo ou diretório não encontrado)

Se o método não lidar com as exceções, deve especificar os tipos de exceções que podem ocorrer no corpo do método na cláusula throws, para que métodos mais altos na pilha de chamadas possam lidá-las ou especificá-las usando a palavra-chave throws.

O método findFile() especifica que pode lançar IOException. O método main() chama esse método e lida com as exceções lançadas.

Gerar várias exceções

Isso é como usamos a palavra-chave throws para gerar várias exceções.

import java.io.*;
class Main {
　　public static void findFile() throws NullPointerException, IOException, InvalidClassException {
　　　　
　　　　//　Código que pode gerar NullPointerException
　　　　… … …　
　　　　//　Código que pode gerar IOException
　　　　… … …　
　　　　//　Código que pode gerar InvalidClassException　
　　　　… … …　
　　}
　　public static void main(String[] args) {
　　　　try{
　　　　　　findFile();
　　　　}1{
　　　　　　System.out.println(e1.getMessage());
　　　　}2{
　　　　　　System.out.println(e2.getMessage());
　　　　}
　　}
}

Aqui, o método findFile() especifica que pode lançar NullPointerException, IOException e InvalidClassException em sua cláusula throws.

Observe que ainda não tratamos NullPointerException. Isso é porque é uma exceção não verificada. Não é necessário especificá-lo na cláusula throws e tratá-lo.

palavra-chave throws com try...catch...finally

Pode haver vários métodos que causem exceções. Escrever try...catch para cada método será tedioso e o código ficará longo e difícil de entender.

Quando você verificou exceções que não deseja capturar no método atual (exceções que devem ser tratadas), throws também é útil.

palavra-chave Java throw

A palavra-chave throw é usada para lançar explicitamente uma exceção.

Quando uma exceção é lançada, o fluxo de execução do programa muda de um bloco try para um bloco catch. Usamos a palavra-chave throw no método.

Sua sintaxe é:

lança throwableObject;

Um objeto Throwable é uma instância da classe Throwable ou de uma subclasse da classe Throwable.

Exemplo2lança palavra-chave Java

class Main {
　　public static void divideByZero() {
　　　　lança new ArithmeticException("tentativa de divisão por zero");
　　}
　　public static void main(String[] args) {
　　　　divideByZero();
　　}
}

Resultados de Saída

Exceção na thread "main" java.lang.ArithmeticException: tentativa de divisão por zero
　　　　at Main.divideByZero(Main.java:3)
　　　　at Main.main(Main.java:7)
estado de saída　1

Neste exemplo, explicitamente lançamos ArithmeticException.

Atenção: ArithmeticException é uma exceção não verificada. Normalmente, não há necessidade de lidar com exceções não verificadas.

Exemplo3lança exceção vermelha

import java.io.*;
class Main {
　　public static void findFile() throws IOException {
　　　　throw new IOException("Arquivo Não Encontrado");
　　}
　　public static void main(String[] args) {
　　　　try {
　　　　　　findFile();
　　　　　　System.out.println("Resto do código do bloco try");
　　　　} catch (IOException e) {
　　　　　　System.out.println(e.getMessage());
　　　　}
　　}
}

Resultados de Saída

Arquivo Não Encontrado

O método findFile() lança uma IOException ao passar uma mensagem para o construtor.

Observe que, como é uma exceção de verificação, deve ser especificada na cláusula throws.

O método que chama findFile() precisa lidar com essa exceção ou especificá-la usando a palavra-chave throws.

Já tratamos essa exceção no método main(). Quando a exceção é lançada, o fluxo de execução do programa é transferido entre os bloco try e catch. Portanto, o restante do código no bloco try será pulado e as instruções no bloco catch serão executadas.