Palavra-chave throws em Java

A palavra-chave throws em Java é usada para declarar que um método pode lançar uma ou mais exceções. Ao contrário da palavra-chave throw, que é usada para lançar uma exceção, throws é usada na assinatura de um método para indicar que o método pode lançar uma exceção que deve ser tratada ou propagada para o método chamador.

Uso da Palavra-chave throws

1.Declaração de Exceções em Métodos: Quando um método pode lançar uma exceção, você usa throws para informar os usuários do método sobre as exceções que podem ser lançadas.

public class Exemplo {
    public void metodoQueLancaExcecao() throws IOException {
        // Código que pode lançar IOException
        FileInputStream fis = new FileInputStream("arquivo.txt");
    }
}

No exemplo acima, o método metodoQueLancaExcecao declara que pode lançar uma IOException. O código que chama este método deve tratar ou declarar a exceção.

2.Propagação de Exceções: Você pode usar throws para propagar exceções para o método chamador, permitindo que a exceção seja tratada em um nível superior.

public class Validador {
    public void validar() throws SQLException {
        metodoQuePodeLancarSQLException();
    }

    private void metodoQuePodeLancarSQLException() throws SQLException {
        // Código que pode lançar SQLException
    }
}

Neste exemplo, validador.validar propaga a SQLException lançada por metodoQuePodeLancarSQLException.

3.Tratamento de Exceções Declaradas: Quando um método declara que pode lançar uma exceção, o código que chama este método deve estar preparado para tratar a exceção, usando um bloco try-catch.

public class Teste {
    public static void main(String[] args) {
        Validador validador = new Validador();
        try {
            validador.validar();
        } catch (SQLException e) {
            System.out.println("Erro: " + e.getMessage());
        }
    }
}

No exemplo acima, o bloco try-catch captura a SQLException que pode ser lançada pelo método validar.

4.Exceções Verificadas e Não Verificadas:

• Exceções Verificadas: Exceções que são subclasses de Exception (exceto RuntimeException) e que devem ser tratadas ou declaradas.

• Exceções Não Verificadas: Exceções que são subclasses de RuntimeException e não precisam ser tratadas ou declaradas.

public class Exemplo {
    public void metodo() throws IOException {
        // Código que pode lançar IOException (exceção verificada)
    }

    public void metodoComExcecaoNaoVerificada() {
        // Código que pode lançar RuntimeException (exceção não verificada)
        throw new RuntimeException("Exceção não verificada");
    }
}

Exemplo Completo

Aqui está um exemplo completo que demonstra o uso de throws para declarar exceções e a forma como elas são tratadas:

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ExemploThrows {
    public void lerArquivo(String nomeArquivo) throws IOException {
        FileInputStream fis = new FileInputStream(nomeArquivo);
        // Lê o arquivo
        fis.close();
    }

    public static void main(String[] args) {
        ExemploThrows exemplo = new ExemploThrows();
        try {
            exemplo.lerArquivo("arquivo.txt");
        } catch (IOException e) {
            System.out.println("Erro ao ler o arquivo: " + e.getMessage());
        }
    }
}

Resumo

• throws é usado na assinatura de um método para declarar que ele pode lançar uma ou mais exceções.
• O código que chama um método com throws deve tratar ou declarar essas exceções.
• Exceções verificadas devem ser declaradas com throws, enquanto exceções não verificadas não precisam ser explicitamente declaradas.

O uso de throws permite um melhor controle sobre o tratamento de erros e ajuda a garantir que as exceções sejam tratadas de maneira apropriada no fluxo de controle do seu programa.