1. Introdução
Tente ... pegar ... finalmente é provavelmente uma frase com a qual todos estão familiarizados, e parece muito simples de usar, e parece logicamente fácil de entender. No entanto, o "aprendizado" que experimentei pessoalmente me disse que isso não é tão simples e obediente quanto imaginei. Não acredita? Em seguida, observe o código abaixo, qual será o resultado depois que ele for executado? Não olhe para as respostas para trás, nem você permite que o código seja executado para ver as respostas reais. Se sua resposta estiver correta, você não precisará perder tempo lendo este artigo.
teste de pacote; classe pública testException {public testException () {} boolean testex () lança exceção {boolean ret = true; tente {ret = testEx1 (); } catch (Exceção e) {System.out.println ("testex, exceção de captura"); ret = false; jogar e; } finalmente {System.out.println ("testex, finalmente; retorno value =" + ret); retornar ret; }} boolean testex1 () lança exceção {boolean ret = true; tente {ret = testex2 (); if (! ret) {return false; } System.out.println ("testEx1, no final da tentativa"); retornar ret; } catch (Exceção e) {System.out.println ("testex1, exceção de captura"); ret = false; jogar e; } finalmente {System.out.println ("testEx1, finalmente; retorno value =" + ret); retornar ret; }} boolean testex2 () lança exceção {boolean ret = true; tente {int b = 12; int c; for (int i = 2; i> = -2; i--) {c = b / i; System.out.println ("i =" + i); } retornar true; } catch (Exceção e) {System.out.println ("testex2, exceção de captura"); ret = false; jogar e; } finalmente {System.out.println ("testex2, finalmente; retorno value =" + ret); retornar ret; }} public static void main (string [] args) {testException testException1 = new testException (); tente {testException1.testEx (); } catch (Exceção e) {e.printStackTrace (); }}} Qual é a sua resposta? É a resposta abaixo?
i = 2
i = 1
testex2, exceção de captura
testex2, finalmente; Valor de retorno = false
TestEx1, exceção de captura
testex1, finalmente; Valor de retorno = false
testex, exceção de captura
testex, finalmente; Valor de retorno = false
Se sua resposta for realmente mencionada acima, você está errado. ^_^, então eu sugiro que você leia este artigo com cuidado ou use o código acima para modificar, executar e testar de acordo com várias situações. Você descobrirá que há muitas coisas que não são tão simples quanto originalmente imaginadas. Agora publique a resposta correta:
i = 2
i = 1
testex2, exceção de captura
testex2, finalmente; Valor de retorno = false
testex1, finalmente; Valor de retorno = false
testex, finalmente; Valor de retorno = false
Observação:
Finalmente, o bloco de declaração não deve aparecer, o retorno deve aparecer. O retorno RET acima é de preferência outra instrução para lidar com a lógica relevante.
2. Exceção de Java
Exceções referem -se a várias situações que ocorrem inesperadamente, como: arquivo não encontrado, falha de conexão de rede, parâmetros ilegais, etc. Uma exceção é um evento que ocorre durante a execução do programa e interfere no fluxo de instrução normal. Java descreve várias exceções por meio de muitas subclasses da classe jogável na API. Portanto, as exceções de Java são objetos, instâncias de subclasses lançáveis, descrevendo condições de erro que aparecem em uma codificação. Quando uma condição é gerada, um erro lançará uma exceção.
Diagrama de hierarquia de classe de exceção Java:
Figura 1 Diagrama de hierarquia de classe de exceção Java
Em Java, todas as exceções têm um ancestral comum, jogável (jogável). O Throwable especifica a semelhança de quaisquer problemas que possam ser transmitidos por meio de aplicativos Java no código por mecanismos de propagação de exceção.
Jogável: existem duas subclasses importantes: exceção e erro. Ambos são subclasses importantes para o manuseio de exceções de Java e cada um contém um grande número de subclasses.
Erro: um erro que o programa não pode lidar, indicando um problema sério na execução do aplicativo. A maioria dos erros não está relacionada às ações executadas pelo escritor de código, mas representa problemas com a JVM (Java Virtual Machine) quando o código é executado. Por exemplo, uma máquina virtual Java executa um erro (Virtual MachineRor) e um OrofMemoryError aparecerá quando a JVM não tiver mais os recursos de memória necessários para continuar a operação. Quando essas exceções ocorrem, a Java Virtual Machine (JVM) geralmente escolhe encerrar os threads.
Esses erros indicam que a falha ocorre quando a própria máquina virtual, ou quando a máquina virtual tenta executar o aplicativo, como um erro de execução da máquina virtual Java (MachineRerror virtual), o erro de definição de classe (noclassDeftError), que é possível que os recursos que se ocorrem. Para um aplicativo bem projetado, mesmo que ocorra um erro, ele não deve essencialmente tentar lidar com as exceções que causa. Em Java, o erro é descrito por uma subclasse de erro.
Exceção: uma exceção que o programa em si pode lidar.
A classe de exceção tem uma subclasse importante, RuntimeException. A classe RuntimeTimeException e suas subclasses representam um erro levantado por "Operações de JVM comuns". Por exemplo, se você tentar usar uma referência de objeto nulo, o divisor zero ou a matriz dos limites, uma exceção de tempo de execução (NullPointerException, arithmeticexception) e ArrayIndexoutOfBoundException são levantados respectivamente.
NOTA: A diferença entre exceções e erros: Exceções podem ser tratadas pelo próprio programa, mas os erros não podem ser tratados.
Geralmente, as exceções Java (incluindo exceção e erro) são divididas em exceções verificadas e exceções desmarcadas.
Exceções podem ser verificadas (exceções que devem ser tratadas pelo compilador): é fácil de ocorrer e exceções razoáveis e tolerantes quando o programa correto estiver em execução. Embora a exceção verificável seja uma condição anormal, sua ocorrência é previsível até certo ponto e, uma vez que uma condição anormal ocorre, ela deve ser tratada de alguma forma.
Exceto pela RunTimeException e suas subclasses, outras classes de exceção e suas subclasses são todas as exceções verificáveis. A característica dessa exceção é que o compilador Java o verificará, ou seja, quando essa exceção pode ocorrer no programa, pegue-o com a instrução Try-Catch ou jogue-a com a cláusula de arremesso, caso contrário, a compilação não passará.
Exceções não controláveis (exceções de que o compilador não requer descarte forçado): incluindo exceções de tempo de execução (RunTimeException e suas subclasses) e erros (erro).
Exceção Esta exceção é dividida em duas categorias: exceção de tempo de execução e exceção não intermediária (exceção de compilação). Essas exceções devem ser tratadas o máximo possível no programa.
Exceções de tempo de execução: todas são aula de execução de tempo de execução e suas exceções de subclasse, como NullPointerException (exceção do ponteiro nulo), indexOutOfBoundSexception (exceção dos limites subscritos), etc. Essas exceções não o controlam. Essas exceções geralmente são causadas por erros lógicos do programa, e os programas devem evitar tais exceções o máximo possível de uma perspectiva lógica.
A característica da exceção de tempo de execução é que o compilador Java não o verificará. Ou seja, quando essa exceção pode ocorrer no programa, mesmo que não seja capturada com a instrução Try-Catch e jogada com a cláusula de arremesso, ela será compilada e passada.
Exceção não-ruptura (exceção de compilação): é uma exceção diferente da RunTimeException e pertence à classe de exceção e suas subclasses em termos de tipo. Do ponto de vista da sintaxe do programa, é uma exceção que deve ser processada. Se não for processado, o programa não poderá ser compilado e aprovado. Como ioexception, sqlexception, etc. e exceções de exceção definida pelo usuário, em geral, nenhuma exceção de verificação personalizada é verificada.
3. Mecanismo de manuseio de exceção
Em aplicativos Java, o mecanismo de manuseio de exceção é: Exceções e pegue exceções.
Jogue uma exceção: quando ocorre um erro em um método e aumenta uma exceção, o método cria um objeto de exceção e o entrega ao sistema de tempo de execução. O objeto de exceção contém informações de exceção, como o tipo de exceção e o status do programa quando a exceção ocorre. O sistema de tempo de execução é responsável por encontrar e executar o código para lidar com exceções.
Exceção de captura: Após o método lançar uma exceção, o sistema de tempo de execução será transformado em busca de um manipulador de exceção adequado. Um manipulador de exceção em potencial é uma coleção de métodos que permanecem na pilha de chamadas, quando ocorre uma exceção. Quando o tipo de exceção que o processador de exceção pode lidar é consistente com o tipo de exceção lançado pelo método, é um processador de exceção adequado. O sistema de tempo de execução começa com o método em que ocorre uma exceção e, em seguida, olha para os métodos na pilha de chamadas, até encontrar um método contendo um manipulador de exceção adequado e o executa. Quando o sistema de tempo de execução atravessa a pilha de chamadas e não encontra um manipulador de exceção adequado, o sistema de tempo de execução termina. Ao mesmo tempo, significa o término do programa Java.
Para exceções de tempo de execução, erros ou exceções detectáveis, os métodos de manuseio de exceção exigidos pela tecnologia Java são diferentes.
Devido às exceções indetectáveis de tempo de execução, a fim de implementar o aplicativo de maneira mais razoável e fácil, o Java estipula que as exceções de tempo de execução serão automaticamente lançadas pelo sistema de tempo de execução do Java, permitindo que o aplicativo ignore as exceções do tempo de execução.
Para erros que podem ocorrer durante a operação do método, o Java permite que o método não jogue nenhuma declaração quando o método não deve ser capturado. Como a maioria das exceções de erros são situações que nunca podem ocorrer e também são exceções de que aplicativos razoáveis não devem capturar.
Para todas as exceções verificáveis, Java estipula que um método deve ser capturado ou declarado fora do método de arremesso. Ou seja, quando um método escolhe não capturar uma exceção verificável, deve declarar que a exceção será lançada.
Um método que pode capturar exceções requer o fornecimento de um tipo correspondente de manipulador de exceção. A exceção capturada pode ser causada por uma exceção levantada e lançada por sua própria declaração, ou uma exceção lançada por um sistema de tempo de execução chamado ou Java, etc. Em outras palavras, a exceção de que um método pode capturar deve ser uma exceção lançada pelo código Java em algum lugar. Simplificando, as exceções são sempre jogadas primeiro e depois capturadas.
Qualquer código Java pode lançar exceções, como: código escrito por si mesmo, codificar o pacote de ambiente de desenvolvimento Java ou o sistema de tempo de execução Java. Não importa quem seja, você pode fazer uma exceção através da declaração de arremesso de java.
Qualquer exceção lançada do método deve ser usada com a cláusula de arremessos.
Exceções de captura são alcançadas por meio de declarações de tentativa ou declarações de tentativa de finalmente.
De um modo geral, Java estipula que exceções verificáveis devem ser capturadas ou declaradas. Permite ignorar o RuntimeException e o erro não controlados.
3.1 Exceções de captura: tente, pegue e finalmente
1. Declaração de catch-capat
Em Java, as exceções são capturadas por uma declaração de tentativa. Sua forma geral de sintaxe é:
tente {// Código do programa onde as exceções podem ocorrer} catch (tipo 1 id1) {// pegue e lide com o tipo de exceção jogado por Try Type1} Catch (tipo 2 ID2) {// Catch and lida com o tipo de exceção jogado por Try Type2}Um par de aparelhos após a palavra -chave experimenta um pedaço de código que pode ter uma exceção, que é chamada de área de monitoramento. Se ocorrer uma exceção durante o método Java durante a execução, um objeto de exceção será criado. Jogue a exceção fora da área de monitoramento e o sistema de tempo de execução do Java tenta encontrar uma cláusula de captura correspondente para capturar a exceção. Se houver uma cláusula de captura correspondente, execute seu código de manuseio de exceção e a instrução Try-Catch termina.
O princípio da correspondência é: se o objeto de exceção jogado pertence à cláusula de exceção da cláusula de captura ou pertence a uma subclasse da classe de exceção, considera -se que o objeto de exceção gerado corresponde ao tipo de exceção capturado pelo bloco de captura.
Exemplo 1 Pegue o "divideiro é 0" Exceção lançada pela declaração de arremesso.
classe pública testException {public static void main (string [] args) {int a = 6; int b = 0; tente {// tente a área de monitoramento se (b == 0) lança nova arithmeticexception (); // Exceção de lançamento através do Sistema de declaração de arremesso.out.println ("O valor de A/ B é:" + A/ B); } catch (arithmeticexception e) {// Catch Exception System.out.println ("O programa tem uma exceção e a variável b não pode ser 0."); } System.out.println ("O programa termina normalmente."); }}Resultado em execução: o programa tem uma exceção e a variável B não pode ser 0.
O programa termina normalmente.
Exemplo 1 Na área de monitoramento de tentativa, use se a declaração para julgar. Quando a condição de erro de "divisor é 0" é estabelecida, uma exceção de aritmeticexception é criada e a declaração de arremesso lança a exceção ao sistema de tempo de execução do Java. O sistema encontra uma captura de manipulador de exceção correspondente e executa o código de manuseio de exceção correspondente. Imprima "O programa tem uma exceção e a variável B não pode ser 0." A instrução Try-Catch termina e continua o fluxo do programa.
De fato, o arithmeticexception, como "Divider Is 0", é uma subclasse do RUNTimexception. A exceção do tempo de execução será lançada automaticamente pelo sistema de tempo de execução e não há necessidade de usar uma instrução de arremesso.
EXEMPLO 2: Pegue a exceção do arithmeticexception causada pelo "divisor é 0" jogando automaticamente durante o sistema de tempo de execução.
public static void main (string [] args) {int a = 6; int b = 0; tente {System.out.println ("O valor de A / B é:" + a / b); } catch (arithmeticexception e) {System.out.println ("O programa tem uma exceção e a variável b não pode ser 0."); } System.out.println ("O programa termina normalmente."); }}Resultado em execução: o programa tem uma exceção e a variável B não pode ser 0.
O programa termina normalmente.
Declaração no Exemplo 2:
System.out.println ("O valor de A/B é:" + A/B);Um erro de "divisor é 0" foi gerado durante o tempo de execução e uma exceção de aritmeticexception foi levantada. O sistema de tempo de execução cria um objeto de exceção e lança uma área de monitoramento, em vez disso, corresponde à captura de manipulador de exceção apropriada e executa o código de manuseio de exceção correspondente.
Como o custo da verificação das exceções de tempo de execução é muito maior que os benefícios de capturar exceções, as exceções de tempo de execução não podem ser detectadas. O compilador Java permite ignorar exceções de tempo de execução, e um método não pode capturar nem declarar exceções de tempo de execução.
Exemplo 3: Não há captura ou declare que a exceção de tempo de execução é lançada.
classe pública testException {public static void main (string [] args) {int a, b; a = 6; b = 0; // O valor do divisor B é 0 System.out.println (a / b); }}Resultados em execução:
Exceção no tópico "Main" java.lang.arithmeticexception: / por zero
em test.testexception.main (testException.java:8)
Exemplo 4 O programa pode ter uma exceção do divisor 0 e uma exceção do subscrito de matriz fora dos limites.
classe pública testException {public static void main (string [] args) {int [] intray = new int [3]; tente {for (int i = 0; i <= intarray.length; i ++) {intray [i] = i; System.out.println ("IntRarray [" + i + "] =" + INTARRAY [i]); System.out.println ("Intarray [" + i + "] módulo" + (i - 2) + "valores:" + INTARRAY [i] % (i - 2)); }} Catch (ArrayIndexoutOfBoundSexception e) {System.out.println ("Exceção do subscrito de Array Intray."); } catch (arithmeticexception e) {System.out.println ("exceção do divisor 0."); } System.out.println ("Programa termina normalmente."); }}Resultados em execução:
INTARRAY [0] = 0
INTARRAY [0] Módulo-2 Valor: 0
INTARRAY [1] = 1
O valor de intray [1] modulo-1: 0
INTARRAY [2] = 2
Exceção do divisor 0.
O programa termina normalmente.
Exemplo 5 O programa pode experimentar uma exceção do divisor 0, e uma exceção dos subscritos de matriz também pode ocorrer. Durante a execução do programa, o tipo de exceção do arithmeticexception corresponde primeiro, para que a declaração de captura correspondente seja executada:
capt (arithmeticexception e) {System.out.println ("Exceção do divisor 0."); }Deve -se notar que, uma vez que uma captura captura capta o tipo de exceção correspondente, ele entrará no código de manuseio de exceções. Depois que o processamento é concluído, isso significa que toda a instrução Try-Catch termina. Outras cláusulas de captura não têm mais a chance de combinar e capturar tipos de exceção.
O Java descreve os tipos de exceção por meio de classes de exceção, e a hierarquia das classes de exceção é mostrada na Figura 1. Para programas de exceção com várias cláusulas de captura, você deve tentar colocar a cláusula de captura que captura a classe de exceção subjacente em primeiro Caso contrário, a cláusula de captura que captura a classe de exceção subjacente provavelmente será bloqueada.
A classe de exceção de RuntimeException inclui várias exceções comuns no tempo de execução, e a classe Arithmeticexception e a classe ArrayIndexoutOfBoundSexception são subclasses. Portanto, a cláusula de captura da classe de exceção de tempo de execução deve ser colocada no final, caso contrário, pode bloquear o manuseio de exceção subsequente ou causar um erro de compilação.
2. Declaração de Try-Catch-Finally
A instrução Try-Catch também pode incluir a terceira parte, que é a cláusula finalmente. Indica o que deve ser executado, independentemente de ocorrer uma exceção ou não. A forma geral de sintaxe da declaração de Try-Catch-Finally é:
tente {// Código do programa que pode ocorrer exceção} Catch (tipo 1 id1) {// pegue e processe o tipo de exceção jogado por Try Type1} Catch (tipo2 id2) {// Catch e processe o tipo de exceção lançado por Try Type2} finalmente {// bloco de instruções que serão executadas independentemente de uma exceção ocorrência}}Exemplo 6 Manipulador de exceção com cláusula finalmente.
classe pública testException {public static void main (string args []) {int i = 0; Saudações de string [] = {"Hello World!", "Hello World !!", "Hello World !!!" }; enquanto (i <4) {tente {// preste atenção especial ao design da variável de controle de loop i para evitar causar o infinito loops system.out.println (cumprimentos [i ++]); } catch (ArrayIndexoutOfBoundSexception e) {System.out.println ("ArraySubScript fora dos limites exceção"); } finalmente {System.out.println ("--------------------------"); }}}}Resultados em execução:
Olá mundo!
----------------------------------
Olá mundo !!
----------------------------------
Olá mundo !!!
----------------------------------
Subscrito de Array Exceção fora dos limites
----------------------------------
No Exemplo 6, preste atenção especial ao design do bloco de extratos na cláusula de tentativa. Se o design for o seguinte, ocorrerá um loop morto. Se projetado como:
tente {System.out.println (cumprimentos [i]); i ++; }resumo:
Experimente o bloco: usado para capturar exceções. Depois disso, zero ou mais blocos de captura podem ser conectados. Se não houver bloco de captura, ele deve ser seguido por um bloco finalmente.
Catch Block: Usado para lidar com exceções capturadas pela tentativa.
Finalmente, bloco: as declarações no bloco finalmente serão executadas, independentemente de a exceção ser capturada ou processada. Quando uma declaração de retorno é encontrada em um bloco de tentativa ou bloco de captura, o bloco de declaração finalmente será
Executa antes que o método retorne. Nos 4 casos especiais a seguir, o bloco finalmente não será executado:
1) ocorreu uma exceção no bloco de declaração finalmente.
2) Use System.Exit () no código anterior para sair do programa.
3) O tópico em que o programa está localizado morre.
4) Desligue a CPU.
3. Regra de Try-Catch-Finalmente (Regra Gramatical para Declaração de Manipulação de Excepções):
1) Uma captura ou finalmente o bloco deve ser adicionado após a tentativa. Após o bloco de tentativa, a captura e finalmente os blocos podem ser conectados ao mesmo tempo, mas há pelo menos um bloco.
2) A ordem do bloco deve ser seguida: se o código usar tanto a captura quanto para os blocos, o bloco de captura deverá ser colocado após o bloco de tentativa.
3) O bloco de captura está relacionado ao tipo de classe de exceção correspondente.
4) Um bloco de tentativa pode ter vários blocos de captura. Nesse caso, o primeiro bloco correspondente é executado. Ou seja, a máquina virtual Java corresponde aos objetos de exceção jogados reais com os tipos de exceção declarados por cada bloco de código de captura em sequência. Se o objeto de exceção for um tipo de exceção ou uma instância de sua subclasse, o bloco de código de captura será executado e nenhum outro bloco de código de captura será executado.
5) Estrutura de Try-Catch-Finalmente aninhada.
6) Na estrutura Try-Catch-Finalmente, uma exceção pode ser re-ampliada.
7) Além das situações a seguir, a execução de finalmente termina: a JVM termina prematuramente (chamada System.Exit (int)); joga uma exceção não tratada no bloco finalmente; O computador é desligado, disparado ou é atacado por um vírus.
4. A ordem de execução de tentativa, captura e finalmente blocos de declaração:
1) Quando a tentativa não capta uma exceção: as declarações no bloco de instrução Try são executadas uma a uma, e o programa pulará o bloco de declaração de captura e executará o bloco de declaração finalmente e as declarações subsequentes;
2) Quando a tentativa captura uma exceção, o bloco de declaração de captura não lida com esta exceção: quando ocorre uma exceção em uma declaração no bloco de instrução Try e no bloco de declaração de captura que não lida com essa exceção, a exceção será lançada à JVM para processamento, e a declaração no bloco de declaração finalmente será executada, mas a declaração após o bloco finalmente será executada;
3) Quando uma tentativa captura uma exceção, o bloco de declaração de captura lidará com a exceção: ele é executado no bloco de instrução Try em ordem. Quando ocorre uma exceção quando ocorre uma exceção em uma determinada declaração, o programa pulará para o bloco de declaração de captura e o combina um a um. Encontre o manipulador correspondente. Outros blocos de declaração de captura não serão executados. No bloco de instrução Try, a declaração após a exceção ocorrer não será executada. Após a execução do bloco de declaração de captura, a declaração no bloco de declaração finalmente será executada e, finalmente, a declaração após a execução do bloco finalmente ser executado;
Ilustração da execução dos blocos de tentativa, captura e finalmente declaração:
A Figura 2 ilustra a execução dos blocos de tentativa, captura e finalmente
3.2 Jogue uma exceção
Qualquer código Java pode lançar exceções, como: código escrito por si mesmo, codificar o pacote de ambiente de desenvolvimento Java ou o sistema de tempo de execução Java. Não importa quem seja, você pode fazer uma exceção através da declaração de arremesso de java. Qualquer exceção lançada do método deve ser usada com a cláusula de arremessos.
1. Exceção de arremesso de arremesso
Se um método pode ter uma exceção, mas não tiver a capacidade de lidar com essa exceção, você pode usar a cláusula de arremesso para declarar a exceção lançada na declaração do método. Por exemplo, um carro pode falhar ao correr e o próprio carro não pode lidar com essa falha, então deixe o motorista lidar com ele.
A declaração de arremessos é usada para declarar o tipo de exceção a ser lançada quando o método é definido. Se o tipo de exceção de exceção for lançado, o método será declarado para lançar todas as exceções. Várias exceções podem ser divididas usando vírgulas. O formato de sintaxe da declaração de arremessos é:
MethodName lança Exception1, Exception2, .., Exceptionn {} Os arremessos após o nome do método Exception1, Exception2, ..., ExceptionN é a lista de exceções a serem jogadas. Quando um método lança uma lista de exceções de exceções, o método não lida com exceções desses tipos e seus tipos de subclasse, mas será jogado no método que chama o método e será tratado por ele. Por exemplo:
importar java.lang.Exception; classe pública testException {static void pop () lança negativoRraysizeException {// Defina o método e lança a exceção negativaRaySizeException int [] arr = new int [-3]; // Crie uma matriz} public static void main (string [] args) {// Método principal tente {// Try Declarents lida com informações de exceção pop (); // Ligue para o método pop ()} Catch (negativoRraysizeException e) {System.out.println ("Exceção lançada pelo método pop ()"); // Informações de exceção de saída}}}Depois de lançar a exceção ao chamador usando a palavra -chave de arremesso, se o chamador não quiser lidar com a exceção, você poderá continuar jogando -a, mas no final deve haver um chamador que possa lidar com a exceção.
O método POP não lida com a exceção NegativearRaysizeException, mas é tratado pela função principal.
A regra para os arremessos lançar exceções:
1) Se for uma exceção desmarcada, ou seja, erro, tempo de execução ou suas subclasses, você pode declarar a exceção a ser lançada sem usar a palavra -chave arremessos, e a compilação ainda passará sem problemas, mas será lançada pelo sistema em tempo de execução.
2) Quaisquer exceções verificadas que possam ser jogadas pelo método devem ser declaradas. Ou seja, se um método pode ter uma exceção verificável, ele será capturado com uma instrução Try-Catch ou lançá-la com uma declaração de cláusula de arremesso, caso contrário, causará um erro de compilação.
3) Somente quando uma exceção é lançada, o chamador do método deve lidar ou refazer a exceção. Quando o chamador de método não conseguir lidar com a exceção, ele deve continuar jogando -o em vez de engoli -lo inteiro.
4) O método de chamada deve seguir as regras de manuseio de exceção e declaração de exceção verificável. Se um método for substituído, exceções diferentes do método substituído não poderão ser declaradas. Qualquer exceção declarada deve ser uma subclasse semelhante ou da exceção declarada pelo método substituído.
Por exemplo:
Void Method1 () lança IoException {} // Legal // Erro de compilação, a ioException deve ser capturada ou declarada para lançar o void method2 () {method1 (); } // Legal, declare que lança o ioException void Method3 () lança IoException {Method1 (); } // Legal, declare que a exceção de lançamento, ioexception é uma subclasse da exceção void method4 () lança a exceção {method1 (); } // Legal, capture ioexception void method5 () {try {method1 (); } catch (ioexception e) {…}} // Erro de compilação, você deve capturar ou declarar a exceção lançada Method6 () {try {Method1 (); } catch (ioexception e) {lança nova excepção ();}} // legal, declare que a exceção de arremesso void method7 () lança exceção {try {method1 (); } catch (ioexception e) {lança nova exceção ();}} A base para determinar que uma exceção pode ocorrer em um método é a seguinte:
1) Há uma declaração de arremesso no método. Por exemplo, o bloco de código de captura do método de método 7 () acima possui uma instrução de arremesso.
2) Outros métodos são chamados e outros métodos usam a cláusula de arremesso para declarar alguma exceção a ser lançada. Por exemplo, o método Method3 () chama o método Method1 (), e o método Method1 () declara que uma ioException é lançada, portanto, uma ioexception pode ocorrer no método Method3 ().
2. Use Throw to Throw Exception
O arremesso sempre aparece no corpo da função e é usado para lançar uma exceção do tipo jogável. O programa será encerrado imediatamente após a declaração de arremesso, a instrução após não poder ser executada e, em todos os blocos de tentativa, contendo-a (talvez na função de chamada de nível superior) procure blocos de tentativa que contenham a cláusula de captura que a corresponde de dentro para fora.
Sabemos que as exceções são objetos de instância da classe Exception e podemos criar objetos de instância da classe Exception Class a serem lançados através da declaração de arremesso. O formato de sintaxe desta afirmação é:
lançar novo nome de exceção;
Por exemplo, jogue um objeto de exceção da classe IoException:
Jogue nova ioexception;
Deve -se notar que lança apenas objetos de instância que podem lançar a classe lançável ou subclasses. A operação a seguir está incorreta:
lançar uma nova string ("Exception");Isso ocorre porque a string não é uma subclasse da classe jogável.
Se uma exceção de verificação for lançada, você também deve declarar o tipo de exceção de que o método pode lançar o cabeçalho do método. O chamador deste método também deve verificar o manuseio da exceção.
Se todos os métodos lançarem a camada de exceção adquirida por camada, a JVM acabará por processá -la e o processamento também é muito simples, que é imprimir a mensagem de exceção e as informações da pilha. Se um erro ou tempo de execução for lançado, o chamador do método tem a opção de lidar com a exceção.
teste de pacote; importar java.lang.Exception; public class TestException {Static int castient (int x, int y) lança myException {// define o método para lançar uma exceção se (y <0) {// determinar se o parâmetro é menor que 0 lança nova myException ("o divisor não pode ser um número negativo"); // Informações de exceção} retornar x/y; // Valor de retorno} public static void main (string args []) {// Método principal int a = 3; int b = 0; tente {// Try Declarents contém instruções que podem ter exceções int resultado = quociente (a, b); // Chamada de método quoteent ()} catch (myException e) {// lidera o sistema de exceção personalizado.out.println (e.getMessage ()); // Informações de exceção de saída} catch (arithmeticexception e) {// manipulam arithmeticexception excepção System.out.println ("divorceipt não pode ser 0"); // Informações de prompt de saída} Catch (Exceção e) {// lidera outras exceções System.out.println ("Outras exceções ocorreram no programa"); // Informações de prompt de saída}}} classe MyException estende a exceção {// Crie a mensagem de String de classe de exceção personalizada; // Defina o tipo de string variável public myException (string errorMessag) {// Mensagem do método da classe pai = errorMessagr; } public string getMessage () {// substituir a mensagem de retorno getMessage () do método; }}3.3 Cadeia de exceção
1) Se o quociente (3, -1) for chamado, ocorrerá uma exceção da MyException e o programa será transferido para o bloco de código Catch (MyException e) para executar;
2) Se o quociente (5,0) for chamado, uma exceção de aritmeticexception será aumentada devido ao erro "divisor é 0". Ele pertence à classe de exceção de tempo de execução e é automaticamente jogado pelo sistema Java Runtime. O método quiCient () não captura a exceção de aritmeticexception. O sistema de tempo de execução do Java procurará o método principal ao longo da pilha de chamadas do método e fará o upload da exceção jogada ao chamador do método quocient ():
int resultado = quociente (a, b); // Quociente do método de chamada ()
Como esta declaração está na área de monitoramento de tentativa, a aritmeticexception com "divisor é 0" transmitida é jogada pelo sistema de tempo de execução Java e corresponde à cláusula de captura:
capt (arithmeticexception e) {// manipulam arithmeticexception excepcionion system.out.println ("o divisor não pode ser 0"); // Informações de solicitação de saída}O resultado do processamento é que a saída "divisor não pode ser 0". Java, um mecanismo de processamento que passa as informações de exceção para cima, forma uma cadeia de exceção.
A exceção verificável lançada pelo método Java será passada para o método de chamada com capacidade de processamento com base na pilha de chamadas e ao longo da hierarquia da chamada do método, e o nível mais alto será até o método principal. Se a exceção for passada para o método principal, mas o principal não tiver a capacidade de lidar com isso e não lança a exceção através da declaração de arremessos, poderá ocorrer um erro de compilação.
3) Se outras exceções ocorrerem, a captura (exceção e) será usada para capturar. Since Exception is the parent class of all exception classes, if the catch (Exception e) code block is placed in front of the other two code blocks, the subsequent code blocks will never be executed, which makes no sense, so the order of catch statements cannot be replaced.
3.4 Throwable类中的常用方法
注意：catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型，e就是变量名。catch代码块中语句"e.getMessage();"用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:
getCause()：返回抛出异常的原因。如果cause 不存在或未知，则返回null。
getMeage()：返回异常的消息信息。
printStackTrace()：对象的堆栈跟踪输出至错误输出流，作为字段System.err 的值。
有时为了简单会忽略掉catch语句后的代码，这样try-catch语句就成了一种摆设，一旦程序在运行过程中出现了异常，就会忽略处理异常，而错误发生的原因很难查找。
5.Java常见异常
在Java中提供了一些异常用来描述经常发生的错误，对于这些异常，有的需要程序员进行捕获处理或声明抛出，有的是由Java虚拟机自动进行捕获处理。Java中常见的异常类:
1. runtimeException子类:
1、 java.lang.ArrayIndexOutOfBoundsException
数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
2、java.lang.ArithmeticException
算术条件异常。譬如：整数除零等。
3、java.lang.NullPointerException
空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等
4、java.lang.ClassNotFoundException
找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。
5、java.lang.NegativeArraySizeException 数组长度为负异常
6、java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常
7、java.lang.SecurityException 安全性异常
8、java.lang.IllegalArgumentException 非法参数异常
2.IOException
IOException：操作输入流和输出流时可能出现的异常。
EOFException 文件已结束异常
FileNotFoundException 文件未找到异常
3. 其他
ClassCastException 类型转换异常类
ArrayStoreException 数组中包含不兼容的值抛出的异常
SQLException 操作数据库异常类
NoSuchFieldException 字段未找到异常
NoSuchMethodException 方法未找到抛出的异常
NumberFormatException 字符串转换为数字抛出的异常
StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常
IllegalAccessException 不允许访问某类异常
InstantiationException 当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常
6.自定义异常
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。
在程序中使用自定义异常类，大体可分为以下几个步骤。
（1）创建自定义异常类。
（2）在方法中通过throw关键字抛出异常对象。
（3）如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
（4）在出现异常方法的调用者中捕获并处理异常。
在上面的“使用throw抛出异常”例子已经提到了。
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.