Como lançar exceção em java

Uma exceção é um erro potencial, do qual o sistema Java sinaliza o programa Java. Se a exceção (erro) não for tratada, o tópico em questão parará de operar. Se o programa fosse um thread único, o programa pararia de operar. Considere o seguinte programa: Public Class TheClass
public static void main (string [] args)
Sistema.fora.println ("visto 1");
int numerator = 6;
int denominador = 0;
cociente int = numerador / denominador;
Sistema.fora.println ("visto 2");
Sistema.fora.println (quociente);

Este programa tenta dividir por 0 na quarta declaração no método main (). Em matemática, nenhum número deve ser dividido por 0. Computadores também não permitem isso. Este programa deve imprimir “visto 1”, então se a divisão por zero for possível pelo computador, o programa deve imprimir “visto 2” e depois imprimir o quociente de 6 dividido por zero.

Este programa é compilado com sucesso pelo compilador Javac. No entanto, quando o programa é executado pela Java Virtual Machine (sistema operacional), "Visto 1" é impresso e o programa para na quarta declaração, onde a divisão por zero é esperada, de onde (onde e) uma mensagem de erro é emitido (exibido). O programa para de executar na declaração de divisão por zero, imprime uma mensagem de erro e para de operar. Depois disso, as duas últimas declarações não são executadas (não opere).

No entanto, se isso fosse multiplicação por zero, o que é permitido, as duas últimas declarações teriam sido executadas. Este artigo fornece o básico de jogar e lidar com uma exceção em Java.

Erros de manuseio

Com o Java, é possível lidar com um erro, como a divisão por zero, com código simples; para que as declarações (codificação) após o erro devem operar (sejam executadas). Qual é o erro aqui? - O erro aqui é divisão por zero. O código (solução) do programador não deve permitir que o erro ocorra. O programador precisa codificar o que é conhecido como lançar o erro, que é um novo objeto de exceção. O objeto de exceção deve ser pego. Quando o objeto de exceção é capturado, o programa precisa se recuperar dele. Recuperar de um erro significa lidar com a exceção.

A classe de biblioteca de exceção lida com o erro mais do que o programador. A classe de exceção não precisa ser importada no início do programa. Essa importação é feita automaticamente, sem a ajuda do programador.

A classe de exceção

Há duas classes principais de manuseio de erros em Java: a classe de exceção e a classe de erro. Este artigo lida apenas com a aula de exceção. Como personagem, a classe de exceção conhece erros comuns, como divisão por zero e valores nulos indesejados em uma corda literal.

Quando um novo objeto de exceção é lançado, logo após a declaração que resultaria em um erro, a biblioteca da classe de exceção saberia o erro; Se for um erro comum. A classe de exceção não precisa ser importada no início do programa. Essa importação é feita automaticamente, sem a ajuda do programador.

A declaração de tentativa de Java

A declaração de tentativa é uma declaração composta, consistindo no bloco de tentativa e um bloco de captura. Na forma simplificada, a sintaxe é:

tentar
// Declaração de problemas;
lançar uma nova exceção ();
* declarações se não ocorrer erro *

Catch (Exceção e)
Sistema.fora.println ("mensagem de exceção:" + e.getMessage ());

Tente é uma palavra reservada; Catch é uma palavra reservada. O bloqueio de tentativa tem a declaração do problema. Uma declaração como,

cociente int = numerador / denominador;

é uma declaração de problema. Se o denominador não for zero, nenhum erro ocorre. Se o denominador for zero, isso é um erro. A declaração de arremesso normalmente seria,

lançar uma nova exceção ();

Esta declaração de arremesso deve ocorrer imediatamente após a declaração do problema. Se ocorrer um erro, a declaração de arremesso lança um novo objeto de exceção. Observe os parênteses. Se o denominador for 0, um novo objeto de exceção será jogado. Abaixo da declaração de arremesso estão outras declarações que seriam executadas se nenhum erro ocorreu.

O bloco de captura acima tem uma declaração. Pode ter mais. A declaração de arremesso no bloco de tentativa lança um objeto de exceção, que é capturado nos parênteses da assinatura do bloco de captura, para processamento adicional em seu bloco. Esta atividade é semelhante a uma chamada de método, com um argumento a ser recebido pelos parênteses da implementação do método para processamento adicional no bloco do método.

Lembre -se de que o objeto de exceção pode reconhecer diferentes tipos de erros comuns e lidar com eles. O objeto de exceção tem o método, getMessage (). Este método retorna uma mensagem que o usuário pode entender como a causa do erro. Esta chamada de método é empregada dentro do bloco de captura.

O programa a seguir coloca a declaração de tentativa composta em prática, com o problema de divisão por zero acima:

classe pública theClass
public static void main (string [] args)
Sistema.fora.println ("visto 1");
int numerator = 6; int denominador = 0; quotiente int;
tentar
if (denominador == 0)
quociente = numerador / denominador;
lançar uma nova exceção ();

outro
quociente = numerador / denominador;
Sistema.fora.println ("visto 2");
Sistema.fora.println (quociente);

Catch (Exceção e)
Sistema.fora.println ("mensagem de exceção:" + e.getMessage ());

Sistema.fora.println ("continua");

O bloqueio de tentativa tem uma declaração IF composta. A parte IF executaria a declaração do problema quando o denominador for zero. A parte mais executada executaria a declaração do problema quando nenhum erro ocorreria quando o denominador não for zero. Isso significa que o programador precisa guiar para o emprego do esquema de manuseio de exceção. E assim, nesse caso, a declaração do problema foi digitada duas vezes: uma vez na parte ift e uma vez na parte mais. A declaração do problema não é precedida por int porque o quociente foi declarado antes da declaração de tentativa composta.

No bloco de tentativa, a declaração de arremesso está logo abaixo da declaração do problema na parte if da declaração if-Compound. Não está na parte da declaração de IF composto. Não precisa estar lá porque a parte mais é para a situação em que o denominador (operando) não é zero (não tem problema).

Leia o programa acima. O numerador é 6. Se o denominador fosse 2, a saída teria sido:

visto 1
visto 2
3
Continuou

Isso significa que a outra parte da declaração IF composta foi executada, não a parte IF da declaração if-Compound. De fato, o IF-Part (Code) da declaração IF composto não foi executado porque o denominador não era zero. O restante do código no bloco de tentativa foi executado. O restante do código no bloco de tentativa deve ser executado.

Quando o denominador for 0, o programa produzirá a saída:

visto 1
Mensagem de exceção: / por zero
Continuou

Somente o código na parte se parte do bloco de tentativa foi executado nesta situação. Isso significa que a declaração de arremesso foi executada. A parte mais importante e o código abaixo da declaração if composta não foram executados. Eles normalmente não são executados nesta situação.

O bloco de captura não é executado quando não há problema. Agora, o bloco de captura foi executado. Isto é, o código de declaração único no bloco de captura foi executado. O novo objeto de exceção é jogado, foi recebido como e. O método getMessage () do objeto, e que conhece os erros comuns (incluindo o erro de divisão por zero) retornou a mensagem "/ por zero".

Com esta mensagem de retorno de erro, o usuário saberia que ocorreu um erro de divisão por zero e foi tratado. O manuseio, aqui, significa que a divisão por zero não causou nenhum dano ao programa e, embora o restante do código abaixo do ponto de erro na instrução Try-Compound não seja executado, o código abaixo do try- A declaração composta seria executada. Se o esquema de manuseio não estivesse presente, o programa teria terminado e qualquer código abaixo que não teria sido na declaração de tentativa de composto não teria sido executado.

Exceção de arremesso, por um método

Em Java, a declaração de throw-exception pode lançar uma exceção no bloco de tentativa, como ilustrado acima. Um método também pode lançar uma exceção, mas com uma sintaxe diferente, ainda relacionada ao bloqueio de tentativa. O núcleo do código de tentativa agora está no corpo do método e não no bloco de tentativa. O programa a seguir repete o acima, mas com um método jogando a exceção. A classe com a implementação do método é:

classe Aclass
int mthd (int nume, int deno) lança exceção
int quoti = nume / deno;
Quoti de retorno;

O código principal do método aqui é a declaração do problema. A declaração do problema não está mais no bloqueio (abaixo). A declaração do problema foi digitada uma vez, aqui e para todo o programa (não digitado duas vezes). A expressão de arremesso agora é diferente. Isso é,

joga exceção

prolongando a assinatura do método à direita. "Jogo" aqui são "lances", com um s. Exceção, aqui, não tem os parênteses.

Agora não há necessidade da declaração IF composta em todo o programa. O corpo do método e a "exceção de arremesso" servem ao propósito da semântica da declaração de composto if-else. A classe principal se torna:

classe pública theClass
public static void main (string [] args)
Sistema.fora.println ("visto 1");
int numerator = 6; int denominador = 0; quotiente int;
tentar
Aclasseobj = novo aclass ();
quociente = eobj.MTHD (numerador, denominador);
Sistema.fora.println ("visto 2");
Sistema.fora.println (quociente);

Catch (Exceção e)
Sistema.fora.println ("mensagem de exceção:" + e.getMessage ());

Sistema.fora.println ("continua");

Ele ainda tem a declaração composta de tentativa. No entanto, a declaração do problema não está aqui e não é digitada duas vezes. A instrução composta if-else também não está aqui. Não é mais necessário em nenhum lugar do programa. A saída com sua mensagem de erro é a mesma de antes, eu.e.

visto 1
Mensagem de exceção: / por zero
Continuou

O comportamento do programa completo é como antes.

A cláusula finalmente

A declaração de tentativa tem três cláusulas: a cláusula de tentativa, a cláusula de captura e a cláusula finalmente. Pode haver mais de uma cláusula de captura - veja mais tarde. O bloco finalmente chega no final da declaração Try-Compound, e é para o programador passar uma mensagem ao usuário de que o possível erro foi tratado. A codificação da cláusula finalmente é opcional. O código a seguir ilustra o uso da cláusula finalmente para o programa acima:

Sistema.fora.println ("visto 1");
int numerator = 6; int denominador = 0; quotiente int;
tentar
Aclasseobj = novo aclass ();
quociente = eobj.MTHD (numerador, denominador);
Sistema.fora.println ("visto 2");
Sistema.fora.println (quociente);

Catch (Exceção e)
Sistema.fora.println ("mensagem de exceção:" + e.getMessage ());

finalmente
Sistema.fora.println ("Qualquer erro foi tratado.");

Se o denominador for 2, a saída seria:

visto 1
visto 2
3
Qualquer erro foi tratado.
Continuou

Se o denominador for 0, a saída seria:

visto 1
Mensagem de exceção: / por zero
Qualquer erro foi tratado.
Continuou

O bloco finalmente é executado, se ocorreu ou não um erro.

Conclusão

Uma exceção é lançada, com a declaração simples no bloco de tentativa, possivelmente codificado com uma instrução IF composta e a declaração do problema. Uma exceção ainda pode ser lançada por um método em relação à declaração de tentativa. Este artigo tem sido o básico de lançar uma exceção em Java.