Tente é como uma rede, que encaixa todas as exceções lançadas pelo código em Try {} e, em seguida, entrega as exceções ao código em Catch {} para processamento. Finalmente, execute o código finalmente. Independentemente de haver exceções no código na tentativa e se a captura pega a exceção, o código em finalmente será executado.
Embora os processadores predefinidos fornecidos pelos sistemas de período de execução Java sejam úteis para depuração, você geralmente deseja lidar com exceções. Há duas vantagens em fazer isso: primeiro, ele permite corrigir erros. Segundo, pode impedir que o programa termine automaticamente. Sempre que ocorrer um erro, se o seu programa parar e imprime uma pista de pilha, a maioria dos usuários ficará confusos. Felizmente, você pode evitar facilmente essa situação.
Para tomar cuidado e lidar com os erros do período de execução, basta colocar o código que você deseja monitorar no bloco de tentativa. Imediatamente após o bloco de tentativa, especifique o exemplo de captura de erro do tipo de exceção que você deseja capturar na cláusula de captura:
tente {code; // Coloque seu próprio código nele;
Por exemplo:
importar java.io. Digite um caractere, por favor "); // Open Enter um personagem, por favor, tente na tela {// Coloque o código do programa que você deseja monitorar no bloco de tentativa. Imediatamente após o bloco de tentativa, especifique o padrão de exceção que você deseja capturar na cláusula de captura ch = (char) system.in.read (); // atribui os caracteres inseridos do teclado para ch} catch (ioexception e) // Se houver um erro no código acima, você captura {} aqui; // nenhuma operação após o sistema de erro.out.println ("Você está digitando caractere:" + ch); // Saída em que você está inserido o caractere de tela: // e o valor de ch}}Quando escrevemos Java, tente .. Chegue, geralmente precisamos adicionar finalmente cláusulas para fechar alguns recursos de IO, por exemplo
InputStream é; tente {is = OpenInputStream (); }} Mas ao usar esse padrão, até os veteranos de Java ocasionalmente cometem alguns erros. Por exemplo, no código acima, quando a função OpenInputStream () lança uma exceção durante a execução, o valor da variável ainda é nulo. Portanto, ele não pode ser capturado pelo bloco de captura, mas é jogado diretamente para a camada de chamada. Pessoalmente, acho que a maneira mais elegante de escrever é chamar diretamente o método ioutils.closequitely () fornecido pelo pacote Commons-IO para fechar o fluxo (ou encapsular um método de perto () você mesmo).
Há outra vantagem de usar este método de escrita, que é que não é fácil cometer erros ao fechar vários recursos de IO, como o seguinte código:
InputStream é; outputStream OS; try {is = OpenInputStream (); if (OS! = NULL) OS.CLOSE (); Quando ocorre um erro no is.close (), os.close () não pode ser executado, resultando no recurso referenciado pelo OS não sendo liberado.
Talvez o Oracle também pense que esse tipo de tentativa ... Catch ... finalmente o código do Boilerplate é desnecessário demais, então fiz algumas modificações na cláusula de tentativa no JDK 7, eliminando a escrita de algum código que fecha manualmente os recursos, tornando o código Parece mais compacto e mais simples. Por exemplo, o código acima pode ser alterado para:
tente (inputStream is = OpenInputStream (); outputStream OS = OpenoutStream ();) {// faça algo} catch (ioexception e) {e.printstacetrace (e);} O Oracle chama a declaração de tentativa (..) aqui a instrução Try-S-S-Resource. Deve -se notar que os objetos referenciados por variáveis no TRY (..) devem ser instâncias que implementam a interface java.io.autoclosable. Ou seja, o recurso em declarações de tentativa de recursos não se limita aos recursos de IO.
Aqui é necessário fornecer algumas explicações adicionais para alguns detalhes da declaração de tentativa de resistência:
O JDK garante que o método Close () de todos os recursos seja chamado, independentemente de o método Close () lançar uma exceção, e a ordem da chamada é revertida da ordem da declaração de recursos.
Todas as exceções lançadas na declaração de tentativa de recursos serão capturadas. Se várias exceções forem lançadas, a exceção subsequente será suprimida. A exceção suprimida pode ser obtida chamando o getSupprimido () definido pela classe jogável por sua vez.
O exemplo acima,
Ao sair da tentativa .. Catch. Na exceção lançada pelo OS.Close (). Você pode obter a exceção lançada pelo IS.Close () através do método getSuppressed ().
Se ocorrer uma ioexception quando o OpenInputStream () for chamado, o OpenOutputStream () não será chamado, os.close () e is.close () não serão chamados, e o bloco de captura captura o lançamento ao chamar a exceção do OpenInputStream ().
Se ocorrer uma ioexception (indicada pelo token E1), então IS.Close () ainda será chamado A exceção capturada pelo bloco de captura é E1.
Além de remodelar o bloco de tentativa, o JDK 7 também simplifica a parte da captura, permitindo que várias cláusulas de captura sejam mescladas. por exemplo:
Try (inputStream is = OpenInputStream (); outputStream OS = OpenOutStream ();) {// Faça algo} Catch (ioexception | xmlparseException | xpathException e) {e.printstacetRace (e);}Além disso, quando você retweete várias exceções, você não precisa mais definir o tipo de exceção em detalhes. Você só precisa declarar a exceção que precisa ser jogada quando o método é definido. por exemplo
// Embora a exceção seja usada aqui para combinar com a ioxception arremessada, o compilador sabe que a exceção realmente jogada na camada superior é a IoException public void Doio () lança ioexception {tente {lança a nova ioexception (); ) {tiro e; PS: Não consigo pensar em nenhum benefício que esse recurso trará
O JDK 7 possui outros novos recursos interessantes de sintaxe, como literais binários, segmentação de números longos com sublinhados, inferência do tipo de parâmetros genéricos, o switch suporta correspondência de strings, etc. Agora, o JDK 8 introduziu alguns recursos úteis. Sem considerar a compatibilidade com versões anteriores, a aplicação apropriada e flexível de alguns recursos de sintaxe pode fazer com que nosso código pareça mais claro e mais conciso até certo ponto.