Tratamento de exceções em Java [com exemplos]
Publicados: 2020-11-12As exceções são o evento indesejado e inesperado de um programa que nunca é desejado por um programador, mas tem que lidar com isso muitas vezes. O lado bom é que é possível com a linguagem orientada a objetos Java mitigar esses eventos indesejáveis através de um conceito chamado 'Tratamento de Exceções em Java '. Ele não repara a exceção, mas fornece uma maneira alternativa de lidar com ela.
Pode haver muitas razões para uma exceção ocorrer, incluindo entrada de dados incorretos, falha de hardware, falha de conexão, servidor inativo, etc. fluxo de um programa no momento em que ocorre um evento inesperado. Ignorar exceções pode fazer com que todo o software falhe e pode resultar em perda de dados.
Agora que temos uma ideia sobre exceções e tratamento de exceções, vamos nos aprofundar nele e também entender como o Java ajuda no tratamento de exceções.
Leia: Perguntas da entrevista sobre tratamento de exceções
Índice
O que é Tratamento de Exceções?
Um desenvolvedor pode prever as exceções que um trecho de código pode lançar durante o tempo de execução. Uma das coisas mais importantes sobre as quais muitos alunos ficam ambíguos é que todas as exceções ocorrem durante o tempo de execução e não no momento da compilação. Java pode manipular exceções apenas durante o tempo de execução. Existem certas palavras-chave usadas em um programa java para criar um bloco de tratamento de exceção.
java.lang.Exception é a classe pai de todas as classes de exceção. A classe Exception é uma subclasse da classe Throwable integrada que é uma subclasse da classe Object . Além de Exception, Throwable também possui outra classe, Error, que é uma condição anormal durante a execução do programa que não pode ser tratada por programas Java, que são a principal diferença entre Error e Exceptions.
Conforme mostrado na figura acima, existem principalmente duas categorias de Exceções em Java. Na próxima seção, veremos detalhadamente os tipos de exceções em Java.
Exceções Java
As causas-raiz das exceções são aquelas causadas pelo programador ou por recursos físicos que falharam devido a alguns motivos. Com base nisso, existem principalmente duas categorias de exceções em Java, conforme os detalhes abaixo:
- Exceção verificada
- Exceção não verificada
1. Exceção Verificada
As exceções verificadas são conhecidas como 'exceções em tempo de compilação', pois são verificadas durante a compilação pelo compilador para monitorar se a exceção é tratada pelo programador. O sistema exibe um erro de compilação.
Alguns exemplos dessas exceções são IOException , Leia: Idéias de Projeto Java para Iniciantes
2. Exceção não verificada
Exceções não verificadas são chamadas de 'Exceções de tempo de execução', pois ocorrem durante o tempo de execução do programa. Exceções não verificadas são normalmente ignoradas durante a compilação e não são verificadas.
Exemplos dessas exceções podem ser bugs em um programa, como erros lógicos ou o uso de APIs incorretas que não estão no controle de um programador e exigem que um administrador do sistema corrija.
Exceção Verificada x Não Verificada
| Pontos de Diferenciação | Exceção verificada Exceção desmarcada Tempo de manuseio | As exceções marcadas são verificadas e tratadas no momento da compilação. | Exceções desmarcadas não são verificadas no momento da compilação. |
| Identificação de exceção | O programa dá um erro de compilação se um método lançar uma exceção verificada. | O programa compila bem, pois o compilador não pode verificar a exceção. | |
| Herança | Eles não herdam a classe RuntimeException. | Eles são as subclasses da classe RuntimeException. | |
| Função do desenvolvedor | Pode ser manipulado pelos desenvolvedores. | Não pode ser manipulado pelos desenvolvedores. |
Compreender as exceções é a etapa principal antes de manipulá-las.
Como o Java ajuda no tratamento de exceções?
Agora que sabemos que existem dois tipos de exceções em Java, a saber, marcadas e desmarcadas. Se um método está lançando uma exceção verificada, ele deve ser tratado com um bloco try-catch ou a palavra- chave ' throws' deve ser declarada para evitar erros de compilação em um programa.
Exemplo de uma exceção verificada:
Este é um programa de leitura de um arquivo chamado 'Java'. Existem três lugares onde uma exceção verificada é lançada:
- FileInputStream: Usado para especificar o caminho e o nome do arquivo throw FileNotFoundException .
- O método read(): Ler o conteúdo do arquivo lança IOException ;
iii. O método close(): Fechar o fluxo de entrada do arquivo lança IOException .
import java.io.*;
exemplo de classe {
public static void main( String args[])
{
FileInputStream fis = null ;
/*O construtor FileInputStream(File filename)
* lança uma exceção verificada FileNotFoundException */
fis = new FileInputStream ( “B:/java.txt” );
intk ;
/* O método read() da classe FileInputStream lança
* uma exceção verificada: IOException
*/
while (( k = fis.read() ) != – 1 )
{
Sistema . fora . imprima (( char )k);
}
/*O método close() fecha o fluxo de entrada do arquivo
* lança IOException */
fis.fechar();
}
}
Saída do programa acima:
Exceção encontrada no encadeamento “principal” java.lang. Erro : Problemas de compilação não resolvidos :
Exceção não tratada FileNotFoundException encontrada
Exceção não tratada IOException encontrada
Exceção não tratada IOException encontrada
O motivo deste erro de compilação: não declaração ou tratamento das exceções.
Deve ler: Projetos Java GitHub
Métodos de Tratamento de Exceções
Existem duas maneiras pelas quais as exceções podem ser tratadas descritas abaixo:
Método 1: Declarando a palavra-chave de exceção 'throws'
No programa acima, todas as três exceções verificadas estão dentro do método main(). Assim, uma forma de evitar o erro de compilação é declarar a exceção no método usando a palavra-chave 'throws'. Como IOException é uma classe pai de FileNotFoundException, ela também cobrirá isso.
Programa atualizado usando a palavra-chave throws:
import java.io.*;
exemplo de classe {
public static void main( String args[]) lança IOException
{
FileInputStream fis = null ;
fis = new FileInputStream ( “B:/java.txt” );
intk ;
while (( k = fis.read() ) != – 1 )
{
Sistema . fora . imprima (( char )k);
}
fis.fechar();
}
}
Saída:
Exiba o conteúdo do arquivo na tela.
Método 2: Manipule exceções usando blocos try-catch.
Esta é uma abordagem mais avançada para a acima e uma das melhores práticas de manipulação de exceção . O código de programa alterado, incluindo os blocos try-catch, é o seguinte:
import java.io.*;
exemplo de classe {
public static void main( String args[])
{
FileInputStream fis = null ;
tente {
fis = new FileInputStream ( “B:/java.txt” );
} catch ( FileNotFoundException fnfe){
Sistema . out .println( “O arquivo não é “ +
“presente no caminho especificado” );
}
intk ;
tente {
while (( k = fis.read() ) != – 1 )
{
Sistema . fora . imprima (( char )k);
}
fis.fechar();
} catch ( IOException ioe){
Sistema . out .println( “Erro de E/S “ +ioe);
}
}
}
Saída:
Esse código eventualmente exibirá o conteúdo do arquivo.
Exemplo de uma exceção não verificada
As exceções não verificadas não são verificadas no momento da compilação. O programa não dará um erro de compilação se não for declarado ou tratado e funcionará bem. O trabalho do desenvolvedor é prever antecipadamente as condições que podem ocorrer causando tais exceções e tratá-las. Todas as exceções Unchecked são subclasses da classe RuntimeException .
exemplo de classe {
public static void main( String args[])
{
int num1= 10 ;
int num2= 0 ;
/*Dividindo qualquer número com 0
* Irá lançar ArithmeticException
*/
int res=num1/num2;
Sistema . out .println(res);
}
}
O código compilará com sucesso com este código, mas durante o tempo de execução, ele lançará ArithmeticException , pois as exceções não verificadas não são verificadas em tempo de compilação. Vamos dar uma olhada em outro exemplo.
exemplo de classe {
public static void main( String args[])
{
int arr[] ={ 1 , 2 , 3 , 4 , 5 };
/* O array tem 5 elementos mas queremos
* exibe o valor do 8º elemento. Ele vai jogar
* Índice de matriz fora dos limites de exceção
*/
Sistema . out .println(arr[ 7 ]);
}
}
Esse código também será compilado com sucesso, pois ArrayIndexOutOfBoundsException é uma exceção não verificada.
Aqui, para lidar com exceções não verificadas, deve haver uma mensagem de exceção exibida para o usuário que ele deseja exibir, mas ela não existe no array.
Manipulando a exceção de código acima com o bloco try-catch
exemplo de classe {
public static void main( String args[]) {
tente {
int arr[] ={ 1 , 2 , 3 , 4 , 5 };
Sistema . out .println(arr[ 7 ]);
}
catch ( ArrayIndexOutOfBoundsException e){
Sistema . out .println( “O índice especificado não existe” +
“na matriz”. );
}
}
}
Saída:
O índice especificado não existe na matriz.
Nota: Pode haver vários blocos catch dentro de um bloco try para lidar com diferentes exceções.
Método 3 : Usando a palavra-chave 'finalmente'
Às vezes acontece que um código precisa ser executado mesmo que ocorra uma exceção. É aqui que a palavra-chave final é usada. Aqui está um código típico com a palavra-chave 'finally'.
public int getPlayerScore(String playerFile)
lança FileNotFoundException {
Conteúdo do scanner = null;
experimentar {
conteúdo = new Scanner( new File(playerFile));
return Integer.parseInt(contents.nextLine());
} finalmente {
if (conteúdo != null ) {
conteúdo.fechar();
}
}
}
Aqui, o bloco final indica o código que queremos que o Java execute ao tentar ler o arquivo.
Mesmo que uma FileNotFoundException seja lançada, o Java chamará o conteúdo de finally .
Podemos lidar com a exceção modificando o código conforme abaixo:
public int PlayerScore(String playerRuns) {
Conteúdo do scanner;
experimentar {
conteúdo = new Scanner(new File(playerRuns));
return Integer.parseInt(contents.nextLine());
} catch (FileNotFoundException noFile ) {
logger.warn(“Arquivo não encontrado.”);
retornar 0;
} finalmente {
experimentar {
if (conteúdo!= null) {
conteúdo.fechar();
}
} catch (IOException ioexc) {
logger.error(“O leitor não pôde ser fechado.”, ioexc);
}
}
}
Conclusão
Com este artigo, tentamos abordar os conceitos básicos de erros e exceções e tratamento de exceções em Java . Esperamos que este guia lhe dê uma boa ideia desse recurso exclusivo que o Java oferece e agora você pode lidar com as exceções e se recuperar melhor delas. Conclusão
Java fornece maneiras de lidar com exceções desde as específicas até as genéricas. Exceções que não podem ser previstas facilmente com antecedência são chamadas de exceções não tratadas. Capturar todas as exceções oferece visibilidade à equipe de desenvolvimento sobre a qualidade do código e as causas-raiz dos erros que podem ser corrigidos rapidamente.
Se você estiver interessado em aprender mais sobre Java, desenvolvimento de pilha completa, confira o Diploma PG do upGrad e IIIT-B em desenvolvimento de software de pilha completa. Ele é cuidadosamente selecionado para profissionais e garante suporte de carreira de 360 graus e inclui projetos ao vivo para trabalhar. Ao final do curso, você será capaz de projetar e construir aplicativos como Swiggy, IMDB, etc.
Isso não soa excitante!-