1. Resumo da exceção de Java:
Exceção significa operação anormal quando o programa está em execução
1. Origem da exceção:
A descrição dos problemas em coisas reais através da forma de classes Java e selado em um objeto
De fato, é a manifestação do objeto depois que Java descreve situações anormais.
2. Existem dois tipos de problemas: um é um problema sério e o outro é um problema sério
Para casos graves, Java descreve isso através da classe de erro
O erro geralmente não é gravado para processá -lo.
Para não graves, Java é descrito pela classe de exceção
Para exceção, você pode usar métodos de processamento direcionados para lidar com isso
3. Exceções comuns incluem: Exceções transfronteiriças do marcador de array, exceções de ponteiro nulo ...
4. Se erros ou exceção têm algum conteúdo comum.
Por exemplo: notícias anormais, causas, etc.
Aula premium de arremesso // as duas classes a seguir são extraídas do mesmo ponto em comum)
| --Error
| --Excption // duas subclasses (existem muitos problemas definidos (exceção ocorre)) /*O nome da classe pai é o nome do sufixo da subclasse* /
Exemplo 1: Exemplo de ocorrência de exceção
classe Demo {public int div (int x, int y) {return x/y; }} classe ExceptionDemo {public static void main (string args []) {Demo d = new Demo (); int x = d.div (4,0); // 0 como divisor system.out.println ("x ="+x); System.out.println ("over"); }}Resultados em execução:
Exceção no tópico "Main" java.lang.arithmeticexception: / por zero
na Demo.div (ExceptionDemo.java:5)
na ExceptionDemo.main (ExceptionDemo.java:15)
A partir dos resultados acima, podemos analisar que uma exceção ocorreu nas linhas 5 e 15. Isso ocorre porque o mecanismo de divisão, o divisor não pode ser 0 e uma exceção será lançada quando a operação for executada.
Exemplo 2: Exemplo de exceção 2, transbordamento de memória
classe Demo {public int div (int x, int y) {return x/y; }} classe ExceptionDemo {public static void main (string args []) { /*Demo d = new Demo (); int x = d.div (4,0); System.out.println ("x ="+x); System.out.println ("over"); */ byte [] arr = novo byte [1024*1024*1000]; }}Resultados em execução:
Exceção no tópico "Main" java.lang.outOfMemoryError: Java Heap Space
na ExceptionDemo.main (ExceptionDemo.java:19)
java.lang.outOfMemoryError: representa exceção de transbordamento de memória
2. Manuseio de exceção:
Para manuseio de exceções, o Java fornece declarações únicas para o processamento
Formatar
tentar
{
código que precisa ser detectado;
}
pegar
{
Código para lidar com exceções; (Método de processamento)
}
Finalmente
{
Código que será definitivamente executado; (Método de processamento)
}
Exemplo 1: Demonstre Try Catch Declaração
classe Demo {public int div (int x, int y) {return x/y; }} classe ExceptionDemo {public static void main (string args []) {Demo d = new Demo (); tente {int x = d.div (4,0); System.out.println ("x ="+x); } catch (Exceção e) {System.out.println ("divisor divorciado"); } System.out.println ("Over"); /*byte [] arr = novo byte [1024*1024*1000];*/}}Resultados em execução:
Há um erro no divisor
sobre
Análise dos resultados: Quando o programa está em execução, quando a declaração da divisão é executada: retornar x/y, um objeto de exceção é gerado. New Archmeticexception (), a instrução Try captura esse objeto com os parâmetros da instrução Catch.
Exceção e = new Archmeticexception ();
Depois de executar a declaração de processamento de captura, o problema é processado, a declaração final está concluída e a saída acabou
Exemplo 2: Execute operações de métodos comuns em objetos de exceção capturados (o método da classe pai jogável)
String getMessage (); // Obtenha informações de exceção
ToString () // Retornar Nome da exceção: Informações de exceção
PrintStackTrace () // Nome da exceção de saída, informações de exceção, localização da ocorrência de exceção
classe Demo {public int div (int x, int y) {return x/y; }} classe ExceptionDemo {public static void main (string args []) {Demo d = new Demo (); tente {int x = d.div (4,0); System.out.println ("x ="+x); } catch (Exceção e) {System.out.println ("divisor divorciado"); // Obtenha o System.out.println de informação de exceção (e.getMessage ()); // Obtenha informações de exceção, nome da exceção System.out.println (e.toString ()); // Nome da exceção de saída, informação de exceção, localização em que a exceção ocorre E.printStackTrace (); } System.out.println ("Over"); /*byte [] arr = novo byte [1024*1024*1000];*/}}Resultados em execução:
Há um erro no divisor
/ por zero
java.lang.arithmeticexception: / por zero
java.lang.arithmeticexception: / por zero
na Demo.div (ExceptionDemo.java:5)
na ExceptionDemo.main (ExceptionDemo.java:17)
sobre
A partir da análise dos resultados em execução, o mecanismo de manuseio de exceção padrão da JVM está realmente chamando o método PrintStackTrace.
Exemplo 3: Duas maneiras de lidar com a exceção de arremesso
1. Jogue -o para a máquina virtual da JVM para processamento
2. Lidar com as exceções jogadas você mesmo
classe Demo {public int div (int x, int y) lança exceção/*A exceção lança onde as exceções podem ocorrer*/{return x/y; }} classe ExceptionDemo {public static void main (string args []) {Demo d = new Demo (); int x = d.div (4,0); System.out.println ("x ="+x); System.out.println ("over"); }}Resultados em execução:
ExceptionDemo.java:15: Erro: Exceção de erro de exceção não relatada; deve ser capturado ou declarado para jogar
int x = d.div (4,0);
^
1 erro
Análise de resultados: Isso ocorre porque nenhuma exceção é processada
Método de processamento 1: Jogue exceções continuamente e deixe a máquina virtual da JVM lidar com ela própria
classe Demo {public int div (int x, int y) lança exceção/*A exceção lança onde as exceções podem ocorrer*/{return x/y; }} classe ExceptionDemo {public static void main (string args []) lança exceção /*Continue lançando exceções e dê à máquina virtual* / {Demo d = new Demo (); int x = d.div (4,0); System.out.println ("x ="+x); System.out.println ("over"); }}Método de manuseio 2: lidar com exceções sozinho
classe Demo {public int div (int x, int y) lança exceção/*A exceção lança onde as exceções podem ocorrer*/{return x/y; }} classe ExceptionDemo {public static void main (string args []) {Demo d = new Demo (); tente // lida com a exceção você mesmo {int x = d.div (4,0); System.out.println ("x ="+x); } catch (Exceção e) {System.out.println ("divisor divorciado"); // Obtenha informações de exceção, nome da exceção System.out.println (e.toString ()); System.out.println ("over"); }}}Resumir:
Declarar exceções sobre funções. É conveniente melhorar a segurança, permitindo que a fonte de chamada seja processada sem processar falhas compiladas.
Exemplo 4: Lidando com várias exceções
1. Ao declarar exceções, é recomendável declarar exceções mais específicas, para que elas possam ser tratadas mais especificamente.
2. Declare várias exceções e existem vários blocos de captura. Não defina uma captura desnecessária rapidamente.
Se houver relações de herança em vários blocos de captura, o bloco de captura de exceção da classe pai será colocado abaixo.
classe Demo {public int div (int x, int y) lança arithmeticexception, ArrayIndexoutOfBoundSexception {int arr [] = new int [x]; System.out.println (arr [4]); retornar x/y; }} classe ExceptionDemo {public static void main (string args []) {Demo d = new Demo (); tente {int x = d.div (4,0); System.out.println ("x ="+x); } catch (arithmeticexception e) / *Divida O objeto de exceção é recebido, a primeira execução é * / {System.out.println ("divisor divorciado"); // Obtenha informações de exceção, nome da exceção System.out.println (e.toString ()); System.out.println ("over"); } catch (ArrayIndexoutOfBoundSexception e) / *Receba o objeto com dados fora dos limites, a segunda execução é * / {System.out.println ("Arrayout"); // Sistema de informação de exceção de saída.out.println (e.toString ()); } Catch (Exceção e) /*Receba a exceção da classe pai e execute -a no final. Recomenda -se não escrever isso, deixe o programa encerrar*//*usar o polimorfismo*/ {System.out.println (e.toString ()); }}}Resultados em execução:
A matriz está sem limites
java.lang.arrayIndexoutOfBoundSexception: 4
sugestão:
Ao processar a captura, você deve definir métodos de processamento específicos no Catch.
Não basta definir E.PrintStackTrace ().
Não apenas escreva uma declaração de saída
Como os usuários não conseguem entender, é melhor salvá -lo em um arquivo e enviá -lo aos nossos desenvolvedores para visualizá -lo regularmente.
Exemplo 5: Exceção personalizada
Você já notou que as exceções que estamos usando são todas encapsuladas em java
No entanto, no desenvolvimento real, as exceções que aparecem em nosso programa podem ser que o Java não esteja encapsulado.
Neste momento, você precisa definir você mesmo
De acordo com o código acima, defino que o divisor não pode ser um número negativo. O código é o seguinte
classe Demo {public int div (int x, int y) lança Fushuexception/*cubra uma exceção*/{if (y <0) {lança nova fushuexception ("o denominador tem um número negativo ------/bu fushu", y); /*O objeto que lança a exceção manualmente*/} retorna x/y; }} classe fushuexception estende a exceção {private int value; Fushuexception (string m, int vale) {super (m); /*Passe os parâmetros para o método getMessage da exceção da classe pai*/ this.value = value; } public int getValue () /*Método personalizado, retorne o número negativo* / {Return Value; }} classe ExceptionDemo {public static void main (string args []) {Demo d = new Demo (); tente {int x = d.div (4, -3); System.out.println ("x ="+x); } catch (fushuexception e) /*pegue objeto de exceção* / {System.out.println (e.getMessage ()+e.getValue ()); } System.out.println ("Over"); }}Resultados em execução:
Um número negativo aparece no denominador ------/bu fushu-3
sobre
A partir dos resultados acima, podemos ver
Neste programa, o divisor é -3, que também é considerado errado e não pode ser realizado.
Então você precisa ter uma descrição personalizada desse problema.
Ao jogar um objeto de exceção dentro da função aparece, a ação de processamento correspondente deve ser dada.
Ou manuseado internamente.
Declare a função para o chamador lidar com isso.
De um modo geral, as exceções aparecem na função e precisam ser declaradas na função.
Verificou -se que havia apenas o nome de exceção no resultado impresso, mas não havia informações de exceção.
Porque a exceção personalizada não define informações.
Como definir informações de exceção?
Porque a operação de informações de exceção foi concluída na classe pai.
Portanto, a subclasse só precisa passar as informações de exceção à classe pai ao construí -las através da instrução super.
Em seguida, você pode obter diretamente informações de exceção personalizada através do método GetMessage.
Exceções personalizadas devem ser a exceção de herança de classe personalizada.
Herdar a razão de exceção:
Um sistema de exceção tem um recurso: porque as classes de exceção e os objetos de exceção são lançados.
Eles são todos jogáveis. Essa capacidade de lançamento é uma característica única do sistema jogável.
Somente classes e objetos neste sistema podem ser operados por lances e lances.
A diferença entre arremessos e arremesso
Os lances são usados nas funções.
O arremesso é usado dentro da função.
A classe de exceção seguida de lances. Pode ser seguido por múltiplos. Separado por vírgulas.
O arremesso é seguido pelo objeto de exceção.
Exemplo 6: Existe uma exceção de subclasse especial na exceção RuntimeException
Se a exceção for lançada no conteúdo da função, a função poderá ser declarada sem declaração e a compilação será passada.
Se a exceção for declarada na função, o chamador não poderá processá -la e a compilação será feita
A razão pela qual não é necessário declarar a função é que o chamador não precisa lidar com isso.
Quando essa exceção ocorre, espero que o programa pare, porque não pode funcionar durante a corrida. Espero que o programa pare após a interrupção do programa.
O programador modificou o código.
classe Demo {public int div (int x, int y) lança Fushuexception/*O resultado de jogar ou não jogar é o mesmo*/{if (y <0) {throw new fushuexception ("o denominador tem um número negativo ------/bu fushu", y); } retornar x/y; }} classe Fushuexception estende RUNTimeException /*Heretance RunTimeException* /{Fushuexception (String m, int value) {super (m); }} classe ExceptionDemo {public static void main (string args []) {Demo d = new Demo (); int x = d.div (4, -3); /*A exceção aparecerá após executar isso, não haverá problema com a compilação*/ System.out.println ("x ="+x); System.out.println ("over"); }}Resultados em execução:
Exceção no thread "Main" Fushuexception: um número negativo aparece no denominador ------/bu fushu
na Demo.div (ExceptionDemo.java:7)
na ExceptionDemo.main (ExceptionDemo.java:26)
A partir dos resultados acima, podemos ver:
Quando a exceção personalizada: se a exceção ocorrer, a operação não poderá ser continuada.
Deixe a exceção personalizada herdar RuntimeException.
Para exceções, existem dois tipos:
1. Exceção detectada durante a compilação.
2. Exceção que não é detectada durante a compilação (exceção de tempo de execução. RuntimeException e suas subclasses)
O artigo acima entende de forma abrangente o mecanismo de manuseio de exceção em Java é todo o conteúdo que compartilhei com você. Espero que possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.