O exemplo deste artigo informa o uso do tratamento anormal de Java. Compartilhe para todos para sua referência. A análise específica é a seguinte:
O mecanismo de processamento anormal do Java pode nos ajudar a evitar ou processar os erros que podem ocorrer no programa, para que o programa não termine inesperadamente ao encontrar alguns erros de recuperação. do código para verificar a situação do erro, que aprimora a legibilidade e a lógica do código. Em Java, as anormalidades representam um objeto de entidade errado.
As anormalidades podem ser divididas em duas categorias; Geralmente, esses programas de erro não podem ser restaurados e a execução do programa precisa ser interrompida; Esse erro geralmente pode ser restaurado sem afetar a operação do programa.
Podemos usar tentativa, captura, finalmente palavras -chave para capturar anormalidades.
1. Tente, pegue
Coloque uma instrução anormal em um bloco Try {} e, em seguida, capture -o no bloco de instrução Catch {}. Se você for dividido por 0:
Public "Exception");} Catch (Exceção e) {E.PrintStackTrace ();} System.out.println ("Finish");Resultados da execução:
Pode -se ver que o acabamento foi impresso, indicando que o programa não terminou devido ao erro que foi removido por 0.
Ao mesmo tempo, também descobrimos que a declaração systerm.out.println abaixo da simpledemo.DeviLE () que ocorreu de forma anormal não foi executada. Uma vez que ocorra anormal, o programa saltará da posição atual sem executar as frases por trás das anormalidades.
2. Finalmente
As declarações no bloco de declaração finalmente serão executadas se ocorrerem ou não anormalidades.
Algumas pessoas podem perguntar, uma vez que as sentenças no bloco final serão executadas se ocorrem ou não anormalidades, que efeito prático isso finalmente tem? Não posso escrever diretamente fora?
Como mostrado acima, adicionamos um retorno no bloco de declaração de captura:
Public "Exceção");} Catch (Exceção e) {E.PrintStackTrace (); );}}Nesse momento, finalmente o acabamento do lado de fora não foi impresso e as finais internas finalmente foram impressas.
Finalmente é muito útil no desenvolvimento real. Por exemplo, abrimos um banco de dados que ocorreu durante o banco de dados de leitura e gravação de dados; portanto, neste momento, devemos desativar a conexão do banco de dados e liberar os recursos correspondentes. Neste momento, é o mais adequado escrever o código que libera o recurso no bloco Finalmente.
Mas deve -se notar que o bloco finalmente não será executado em um caso. Se o programa sair antes da execução do bloco finalmente, como chamar o método System.Exit (), o bloco finalmente não terá a oportunidade de executar.
3. Deixe anormalidades abandonar
Se haverá anormalidades em um método, mas não queremos lidar com essa anormalidade diretamente no método, mas para permitir que o chamador do método seja processado, podemos usar a palavra -chave dos arremessos para declarar esse método para lançar a exceção . Isso é muito comum na função da API fornecida pelo Sun, como o método de leitura em java.io.reader é declarado como lançar uma exceção da IOException:
public int leia
No momento, quando chamamos o método de leitura, devemos colocá -lo no bloco de instrução Try para captura anormal, caso contrário, o compilador relatará um erro e nos forçará a executar a captura anormal.
Obviamente, se não queremos lidar com anormalidades ao ligar para a leitura, também podemos declarar o método de chamar o método de leitura como lança a IoException, para que as anormalidades sejam jogadas fora novamente. Se declararmos uma exceção de exceção na função principal, as informações anormais serão capturadas pela JVM, e o resultado do processamento do processamento da JVM é imprimir as informações anormais e encerrar a operação do programa.
4. Arquitetura de tratamento anormal
Todas as classes anormais são derivadas da classe de exceção. Isso significa que, se não tivermos certeza de que tipo de anormalidades ocorrerá, podemos declarar diretamente um objeto de exceção diretamente na captura para capturar as exceções de todas as classes de exceção e suas subclasses. Mas preste atenção à ordem de captura. Se houver várias capturas por trás de uma tentativa e a primeira captura for declarada pelo objeto de exceção, essa exceção será tratada diretamente pela primeira captura, e a captura posterior não poderá capturar essa anormalidade. Este erro causará erros ao compilar. Como segue: abaixo:
Classe pública CatchDemo {// Exceto para public static int Division (int a, int b) {return a/b;} public static void main (string [] args) {trydemo.div.div Ision (4,0);} Catch (Exceção e) {System.out.println ("classe de exceção");} catch (arithmeticexception e) {System.out.println ("ArithmeticePtion classe");A aritmeticexception de saída do compilador foi capturada, o que significa que a exceção acima capturou essa anormalidade sem captura repetida.
O que aconteceria se essas duas capturas reversassem?
Classe pública CatchDemo {// Exceto para public static int Division (int a, int b) {return a/b;} public static void main (string [] args) {trydemo.div.div Ision (4,0);} Catch (arithmeticexception e) {System.out.println ("ArithMeticexception class");} Catch (Exceção e) {System.out.println ("classe de exceção");Nesse momento, descobrimos que o código passou a compilação e o resultado foi o resultado da aritmeticexception.
Espera -se que este artigo seja útil para o design do programa Java de todos.