Como lidar com exceções java o caminho certo

Como um novato programação

, O conceito de manipulação de exceção pode ser difícil de quebrar a cabeça ao redor. Não que o conceito em si é difícil, mas a terminologia pode fazê-lo parecer mais avançado do que é. E é uma característica tão poderosa que é propenso a utilização indevida e abusiva.Como aprender programação sem todo o stressComo aprender programação sem todo o stressTalvez você decidiu seguir a programação, seja para uma carreira ou apenas como um hobby. Ótimo! Mas talvez você está começando a sentir-se oprimido. Não tão grande. Aqui está a ajuda para facilitar sua viagem.consulte Mais informação

Neste artigo, você vai aprender o que exceções são, por que eles são importantes, como usá-los, e os erros comuns a evitar. A maioria das línguas modernas têm algum tipo de tratamento de exceção, então se você nunca passar de Java, você pode tomar a maioria destas dicas com você.

Compreender Exceções Java

Em Java, uma exceção é um objeto que indica que algo anormal (ou “excepcional”) ocorreu durante a execução do aplicativo. Tais exceções são jogado, o que basicamente significa um objeto de exceção é criada (semelhante à forma como os erros são “levantados”).

A beleza é que você pode pegar exceções lançadas, que lhe permite lidar com a condição anormal e permitir a sua aplicação continue a funcionar como se nada desse errado. Por exemplo, enquanto um ponteiro nulo em C pode travar o seu aplicativo, Java permite jogar e pegar Null Pointer Exceptions antes de uma variável nula tem uma chance de causar um acidente.

Lembre-se, uma exceção é apenas um objeto, mas com uma característica importante: deve ser estendido a partir da Exceção classe ou qualquer subclasse de Exceção. Enquanto Java tem todos os tipos de exceções incorporadas, você também pode criar sua própria se desejar. Algumas das exceções Java mais comuns incluem:

• Null Pointer Exception
• NumberFormatException
• IllegalArgumentException
• RuntimeException
• IllegalStateException

Então o que acontece quando você lançar uma exceção?

Video: Aula de Programação Java 11 - Exceções/Exception

Primeiro, Java olha dentro do método imediato para ver se há código que lida com o tipo de exceção que você jogou. Se um manipulador não existe, ele olha para o método que chamou o método atual para ver se um identificador existe lá. Se não, ele olha para o método que chamou aquele método, e, em seguida, o método seguinte, etc. Se a exceção não é detectada, a aplicação imprime um rastreamento de pilha e, em seguida, falha. (Na verdade, é mais sutil do que simplesmente deixar de funcionar, mas isso é um tópico avançado além do escopo deste artigo.)

UMA rastreamento de pilha é uma lista de todos os métodos que Java percorridos ao olhar para um manipulador de exceção. Aqui está o que um rastreamento de pilha se parece com:

Exception in thread "a Principal" Java.lang.NullPointerExceptionat com.exemplo.meu projeto.Livro.getTitle(Livro.Java:16)em com.exemplo.meu projeto.Autor.getBookTitles(Autor.Java:25)em com.exemplo.meu projeto.Bootstrap.a Principal(Bootstrap.Java:14)

Podemos recolher muito com este. Primeiro, a exceção gerada foi um Null Pointer Exception. Ocorreu no getTitle () método na linha 16 de Book.java. Esse método foi chamado de getBookTitles () na linha 25 da Author.java. que método foi chamado de a Principal() na linha 14 de Bootstrap.java. Como você pode ver, sabendo tudo isso torna a depuração mais fácil.

Mas, novamente, o verdadeiro benefício de exceções é que você pode “lidar” com a condição anormal por captura a exceção, definir as coisas direito, e retomar a aplicação sem bater.

Usando Exceções Java no Código

Vamos dizer que você tem someMethod () que leva um inteiro e executa alguma lógica que poderia quebrar se o inteiro é menor que 0 ou maior que 100. Este poderia ser um bom lugar para lançar uma exceção:

Video: 14 - Criando suas próprias exceções

público vazio someMethod(int valor) {E se (valor lt; 0 || valor gt; 100) {lançar Novo IllegalArgumentException()-}// ...}

A fim de pegar essa exceção, você precisa ir para onde someMethod () é chamado e usar o tente-captura bloco:

Video: Java - Módulo III - Aula 04: Exceções

público vazio callingMethod() {experimentar {someMethod(200)-someOtherMethod()-} pegar (IllegalArgumentException e) {// tratar a exceção aqui}// ...}

Tudo dentro do experimentar bloco será executada em ordem, até que uma exceção é lançada. Assim que uma exceção é lançada, todas as declarações posteriores são ignorados e a lógica do aplicativo salta imediatamente à pegar quadra.

No nosso exemplo, entramos no bloco try e imediatamente chamar someMethod (). Desde 200 não é entre 0 e 100, um IllegalArgumentException é lançada. Isto termina imediatamente a execução de someMethod (), ignora o resto da lógica no bloco try (someOtherMethod () nunca é chamado), e continua a execução dentro do bloco catch.

O que aconteceria se nós chamamos someMethod (50) em vez de? o IllegalArgumentException nunca seria lançada. someMethod () seria executado como normal. O bloco try seria executado como normal, chamando someOtherMethod () quando someMethod () é concluída. Quando someOtherMethod () termina, o bloco de captura seria ignorado e callingMethod () continuaria.

Note que você pode ter vários blocos catch por bloco try:

público vazio callingMethod() {experimentar {someMethod(200)-someOtherMethod()-} pegar (IllegalArgumentException e) {// tratar a exceção aqui} pegar (Null Pointer Exception e) {// tratar a exceção aqui}// ...}

Observe também que um opcional finalmente bloco existe assim:

público vazio método() {experimentar {// ...} pegar (Exceção e) {// ...} finalmente {// ...}}

O código dentro de um bloco é finalmente sempre executado, não importa o quê. Se você tem uma instrução de retorno no bloco try, o bloco finally é executado antes de voltar para fora do método. Se você jogar outra exceção no bloco catch, o bloco finally é executado antes a exceção é lançada.

Você deve usar o bloco finally quando você tem objetos que precisam ser limpos antes do método termina. Por exemplo, se você abriu um arquivo no bloco try e mais tarde emitiu uma exceção, o bloco finally permite que você feche o arquivo antes de deixar o método.

Note que você pode ter um bloco finally sem um bloco catch:

público vazio método() {experimentar {// ...} finalmente {// ...}}

Isto permite-lhe fazer qualquer limpeza necessária, permitindo exceções lançadas para propagar até a pilha de invocação de método (ou seja, você não quer tratar a exceção aqui, mas você ainda precisa limpar primeiro).

Verificado vs. exceções não verificadas em Java

Diferentemente da maioria dos idiomas, Java distingue entre exceções verificadas e exceções não verificadas (Por exemplo C # só tem excepções não assinalada). A exceção verificada devo ser pego no método onde a exceção é lançada ou então o código não irá compilar.

Para criar uma exceção verificada, estendem-se desde Exceção. Para criar uma excepção não verificado, estendem-se desde RuntimeException.

Qualquer método que lança uma exceção verificada deve denotar este na assinatura do método usando o lança palavra-chave. Desde built-in do Java IOException é uma exceção verificada, o seguinte código não irá compilar:

público vazio wontCompile() {// ...E se (someCondition) {lançar Novo IOException()-}// ...}

Você deve primeiro declarar que ele lança uma exceção verificada:

público vazio willCompile() lança IOException {// ...E se (someCondition) {lançar Novo IOException()-}// ...}

Note-se que um método pode ser declarado como lançar uma exceção, mas nunca realmente lançar uma exceção. Mesmo assim, a exceção ainda terá de ser travado ou então o código não irá compilar.

Quando você deve usar marcada ou exceções não verificadas?

A documentação oficial Java tem uma página sobre esta questão. Ele resume a diferença com uma regra sucinta de ouro: “Se um cliente pode ser razoavelmente esperado para se recuperar de uma exceção, torná-lo uma exceção verificada. Se um cliente não pode fazer nada para se recuperar de uma exceção, torná-lo uma exceção não verificada “.

Mas essa diretriz pode ser ultrapassada. Por um lado, exceções verificadas fazer resultado no código mais robusto. Por outro lado, nenhuma outra língua tem exceções verificadas da mesma maneira como Java, que mostra duas coisas: um, o recurso não é útil o suficiente para outras línguas para roubá-lo, e dois, você pode perfeitamente viver sem eles. Além disso, exceções verificadas não jogar bem com expressões lambda introduzidas em Java 8.10 dicas para escrever Cleaner & melhor Código10 dicas para escrever Cleaner & melhor CódigoEscrever código limpo parece mais fácil do que realmente é, mas os benefícios valem a pena. Veja como você pode começar a escrever código mais limpo hoje.consulte Mais informação

Diretrizes para Java Exceções Uso

Exceções são úteis, mas facilmente utilizadas e abusado. Aqui estão algumas dicas e as melhores práticas para ajudá-lo a evitar fazer uma bagunça deles.

• Prefere exceções específicas para exceções gerais. Usar NumberFormatException sobre IllegalArgumentException quando possível, caso contrário usar IllegalArgumentException sobre RuntimeException quando possivel.
• Nunca pegar Throwable! o Exceção classe, na verdade, se estende Throwable, e o bloco catch realmente funciona com Throwable ou qualquer classe que se estende Throwable. No entanto, o Erro classe também se estende Throwable, e você nunca quer pegar uma Erro Porque Erros indicar problemas irrecuperáveis ​​graves.
• Nunca pegar Exceção! InterruptedException estende Exceção, de modo que qualquer bloco que trava Exceção também irá capturar InterruptedException, e isso é uma exceção muito importante que você não quer mexer com (especialmente em aplicações multi-threaded) se você não sabe o que está fazendo. Se você não sabe qual exceção para pegar em vez disso, considere não pegar nada.
• Use mensagens descritivas para facilitar a depuração. Quando você lançar uma exceção, você pode fornecer uma Corda mensagem como um argumento. Esta mensagem pode ser acedida no bloco de captura usando a Exception.getMessage () método, mas se a exceção nunca é pego, a mensagem também aparecem como parte do rastreamento de pilha.
• Tente não pegar e ignorar exceções. Para contornar o inconveniente de exceções verificadas, um monte de novato e programadores preguiçosos irá configurar um bloco catch, mas deixá-lo vazio. Mau! Sempre lidar com isso graciosamente, mas se você não pode, pelo menos imprimir um rastreamento de pilha para que você saiba a exceção foi lançada. Você pode fazer isso usando o Exception.printStackTrace () método.
• Cuidado com o uso excessivo exceções. Quando você tem um martelo, tudo parece um prego. Quando você aprender sobre exceções, você pode se sentir obrigado a transformar tudo em uma exceção ... até o ponto onde a maioria de fluxo de controle do seu aplicativo se resume a manipulação de exceção. Lembre-se, as exceções são destinadas para as ocorrências “excepcionais”!

Agora você deve ser confortável o suficiente com exceções para entender o que eles são, por que eles são usados, e como incorporá-las em seu próprio código. Se você não entender completamente o conceito, tudo bem! Levei um tempo para isso “clicar” em minha cabeça, então não me sinto como você precisa se apressar. Não tenha pressa.6 sinais que você não está destinado a ser um programador6 sinais que você não está destinado a ser um programadorNem todo mundo é cortado para ser um programador. Se você não está completamente certo de que você está destinado a ser um programador, aqui estão alguns sinais que podem apontar na direção certa.consulte Mais informação

Tem alguma dúvida? Sabe de todas as outras dicas relacionadas com a exceção que eu perdi? Compartilhe-os nos comentários abaixo!