1. Resumen de excepción de Java:
La excepción significa operación anormal cuando el programa se está ejecutando
1. Origen de la excepción:
La descripción de los problemas en cosas reales a través de la forma de las clases de Java y sellado en un objeto
De hecho, es la manifestación de objetos después de que Java describe situaciones anormales.
2. Hay dos tipos de problemas: uno es un problema grave, y el otro es un problema grave
Para casos graves, Java lo describe a través de la clase de error
El error generalmente no se escribe para procesarlo.
Para no serios, Java se describe con la clase de excepción
Para excepción, puede usar métodos de procesamiento dirigidos para manejarlo
3. Las excepciones comunes incluyen: excepciones transfronterizas del marcador de esquina de matriz, excepciones de puntero nulo ...
4. Si el error o la excepción tienen un contenido común.
Por ejemplo: noticias anormales, causas, etc.
Lanzamiento // clase premium (las siguientes dos clases se extraen de la misma comunidad)
| --Error
| --Excttion // Dos subclases (hay muchos problemas definidos (se produce la excepción)) /*El nombre de la clase principal es el nombre de sufijo subclase* /
Ejemplo 1: Ejemplo de ocurrencia de excepción
clase de clase {public int div (int x, int y) {return x/y; }} clase 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 de ejecución:
Excepción en el hilo "principal" java.lang.arithmeticexception: / por cero
en Demo.Div (excepcionDemo.Java:5)
en ExceptionDemo.Main (ExceptionDemo.Java:15)
De los resultados anteriores, podemos analizar que se produjo una excepción en ambas líneas 5 y 15. Esto se debe a que el mecanismo de división, el divisor no puede ser 0, y se lanzará una excepción cuando se ejecute la operación.
Ejemplo 2: Excepción Ejemplo 2, desbordamiento de memoria
clase de clase {public int div (int x, int y) {return x/y; }} clase 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 = new Byte [1024*1024*1000]; }}Resultados de ejecución:
Excepción en el hilo "principal" java.lang.OUTOFMemoryError: Java Heap Space
en ExceptionDemo.Main (ExceptionDemo.Java:19)
java.lang.OutofMemoryError: representa la excepción de desbordamiento de la memoria
2. Manejo de excepciones:
Para el manejo de excepciones, Java proporciona declaraciones únicas para el procesamiento
Formato
intentar
{
código que necesita ser detectado;
}
atrapar
{
Código para manejar excepciones; (Método de procesamiento)
}
Finalmente
{
Código que definitivamente se ejecutará; (Método de procesamiento)
}
Ejemplo 1: Demuestre la declaración de prueba de captura
clase de clase {public int div (int x, int y) {return x/y; }} clase ExceptionDemo {public static void main (string args []) {demo d = new Demo (); intente {int x = d.div (4,0); System.out.println ("x ="+x); } capt (excepción e) {system.out.println ("divisor divorciado"); } System.out.println ("Over"); /*byte [] arr = new Byte [1024*1024*1000];*/}}Resultados de ejecución:
Hay un error en el divisor
encima
Análisis de resultados: cuando el programa se ejecuta, cuando se ejecuta la declaración de división: return x/y, se genera un objeto de excepción. New ArchMeticException (), la declaración de prueba captura este objeto con los parámetros de la instrucción Catch.
Excepción e = new ArchMeticException ();
Después de ejecutar la instrucción de procesamiento de captura, el problema se procesa, la declaración final se termina y la salida ha terminado
Ejemplo 2: Realice operaciones de método común en objetos de excepción capturados (el método de la clase principal que se puede lanzar)
String getMessage (); // Obtener información de excepción
toString () // devolver el nombre de la excepción: información de excepción
printStackTrace () // Nombre de excepción de salida, información de excepción, ubicación de la ocurrencia de excepción
clase de clase {public int div (int x, int y) {return x/y; }} clase ExceptionDemo {public static void main (string args []) {demo d = new Demo (); intente {int x = d.div (4,0); System.out.println ("x ="+x); } capt (excepción e) {system.out.println ("divisor divorciado"); // Obtener información de excepción System.out.println (e.getMessage ()); // Obtener información de excepción, nombre de excepción System.out.println (e.ToString ()); // Nombre de excepción de salida, información de excepción, ubicación donde ocurre la excepción E.PrintStackTrace (); } System.out.println ("Over"); /*byte [] arr = new Byte [1024*1024*1000];*/}}Resultados de ejecución:
Hay un error en el divisor
/ Por cero
java.lang.arithmeticexception: / por cero
java.lang.arithmeticexception: / por cero
en Demo.Div (excepcionDemo.Java:5)
en ExceptionDemo.Main (ExceptionDemo.Java:17)
encima
A partir del análisis de los resultados de ejecución, el mecanismo de manejo de excepción predeterminado de JVM en realidad está llamando al método PrintStackTrace.
Ejemplo 3: Dos formas de manejar el lanzamiento de excepciones
1. Tíralo a la máquina virtual JVM para su procesamiento
2. Maneja las excepciones lanzadas tú mismo
Class Demo {public int div (int x, int y) lanza excepción/*Excepción lanza donde pueden ocurrir excepciones*/{return x/y; }} clase 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 de ejecución:
ExceptionDemo.Java:15: Error: Excepción de excepción no reportada Excepción; debe ser capturado o declarado para lanzar
int x = d.div (4,0);
^
1 error
Análisis de resultados: Esto se debe a que no se procesan excepciones
Método de procesamiento 1: arroje continuamente excepciones y deje que la máquina virtual JVM la maneje en sí misma
Class Demo {public int div (int x, int y) lanza excepción/*Excepción lanza donde pueden ocurrir excepciones*/{return x/y; }} clase ExceptionDemo {public static void main (string args []) arroja excepción /*Continuar lanzando excepciones y dando a la máquina virtual* / {demo d = new Demo (); int x = d.div (4,0); System.out.println ("x ="+x); System.out.println ("Over"); }}Manejo del método 2: manejar las excepciones por usted mismo
Class Demo {public int div (int x, int y) lanza excepción/*Excepción lanza donde pueden ocurrir excepciones*/{return x/y; }} clase ExceptionDemo {public static void main (string args []) {demo d = new Demo (); intente // manejar la excepción usted mismo {int x = d.div (4,0); System.out.println ("x ="+x); } capt (excepción e) {system.out.println ("divisor divorciado"); // Obtener información de excepción, nombre de excepción System.out.println (e.ToString ()); System.out.println ("Over"); }}}Resumir:
Declarar excepciones a las funciones. Es conveniente mejorar la seguridad, permitiendo que la fuente de llamadas se procese sin el procesamiento de fallas de compilación.
Ejemplo 4: Manejo de múltiples excepciones
1. Al declarar excepciones, se recomienda declarar excepciones más específicas, para que puedan manejarse más específicamente.
2. Declarar varias excepciones, y hay varios bloques de captura. No defina la captura innecesaria rápidamente.
Si hay relaciones de herencia en múltiples bloques de captura, el bloque de captura de excepción de la clase principal se coloca a continuación.
Class Demo {public int div (int x, int y) arroja arithmeticException, arrayindexoUtofboundsexception {int arr [] = new int [x]; System.out.println (arr [4]); regreso x/y; }} clase ExceptionDemo {public static void main (string args []) {demo d = new Demo (); intente {int x = d.div (4,0); System.out.println ("x ="+x); } catch (arithmeticException e) / *Divide el objeto de excepción se recibe, la primera ejecución es * / {System.out.println ("divisor divorciado"); // Obtener información de excepción, nombre de excepción System.out.println (e.ToString ()); System.out.println ("Over"); } Catch (ArrayInDexOutofBoundSException e) / *Recibe el objeto con datos fuera de los límites, la segunda ejecución es * / {System.out.println ("Arrayout"); // Sistema de información de excepción de salida.out.println (e.ToString ()); } Catch (Exception e) /*Recibe la excepción de la clase principal y ejecutarla al final. Se recomienda no escribir esto, deje que el programa termine*//*use polimorfismo*/ {System.out.println (e.ToString ()); }}}Resultados de ejecución:
La matriz está fuera de los límites
java.lang.arrayindexoUtofboundsexception: 4
sugerencia:
Al procesar la captura, debe definir métodos de procesamiento específicos en la captura.
No se define simplemente E.PrintStackTrace ().
No solo escriba una declaración de salida
Debido a que los usuarios no pueden entenderlo, es mejor guardarlo en un archivo y enviarlo a nuestros desarrolladores para verlo regularmente.
Ejemplo 5: Excepción personalizada
¿Has notado que las excepciones que estamos usando están encapsuladas en Java?
Sin embargo, en el desarrollo real, las excepciones que aparecen en nuestro programa pueden ser que Java no está encapsulado.
En este momento, debes definirlo tú mismo
Según el código anterior, defino que el divisor no puede ser un número negativo. El código es el siguiente
clase de demostración {public int div (int x, int y) lanza fushuexception/*top una excepción*/{if (y <0) {throw new Fushuexception ("El denominador tiene un número negativo ------/bu fushu", y); /*El objeto que arroja la excepción manualmente*/} return x/y; }} La clase Fushuexception extiende la excepción {Private Int Value; Fushuexception (string m, int value) {super (m); /*Pase los parámetros al método getMessage de la excepción de la clase principal*/ this.value = valor; } public int getValue () /*Método personalizado, return Número negativo* / {Valor de retorno; }} clase ExceptionDemo {public static void main (string args []) {demo d = new Demo (); intente {int x = d.div (4, -3); System.out.println ("x ="+x); } Catch (Fushuexception e) /*Catch Exception Object* / {System.out.println (e.getMessage ()+e.getValue ()); } System.out.println ("Over"); }}Resultados de ejecución:
Aparece un número negativo en el denominador ------/bu fushu-3
encima
De los resultados anteriores, podemos ver
En este programa, el divisor es -3, que también se considera incorrecto y no se puede realizar.
Entonces debe tener una descripción personalizada de este problema.
Cuando aparece un objeto de excepción dentro de la función, se debe administrar la acción de procesamiento correspondiente.
O manejado internamente.
Declare en la función para que la persona que llame la maneje.
En términos generales, las excepciones aparecen en la función y deben declararse en la función.
Se descubrió que solo había el nombre de excepción en el resultado impreso, pero no había información de excepción.
Porque la excepción personalizada no define información.
¿Cómo definir información de excepción?
Porque el funcionamiento de la información de excepción se ha completado en la clase principal.
Por lo tanto, la subclase solo necesita pasar la información de excepción a la clase principal al construirla a través de la súper declaración.
Luego puede obtener directamente información de excepción personalizada a través del método GetMessage.
Las excepciones personalizadas deben ser una excepción de herencia de clase personalizada.
Heredar la razón de la excepción:
Un sistema de excepción tiene una característica: porque se lanzan tanto las clases de excepción como los objetos de excepción.
Todos son tirables. Esta capacidad de lanzamiento es una característica única del sistema lanzable.
Solo las clases y objetos en este sistema pueden operarse mediante lanzamientos y lanzamientos.
La diferencia entre lanzamientos y lanzamiento
Los tiros se usan en funciones.
Se usa lanzamiento dentro de la función.
La clase de excepción seguida de lanzamientos. Puede ser seguido por múltiples. Separado por comas.
El lanzamiento es seguido por el objeto de excepción.
Ejemplo 6: Hay una excepción de subclase especial en Exception RuntimeException
Si se lanza la excepción en el contenido de la función, la función se puede declarar sin declaración y se aprobará la compilación.
Si la excepción se declara en la función, la persona que llama no puede procesarla y la compilación se realizará a través de
La razón por la que no es necesario declarar la función es que la persona que llama no necesita manejarla.
Cuando ocurre esta excepción, espero que el programa se detenga, porque no puede ejecutarse durante la ejecución. Espero que el programa se detenga después de que el programa se detenga.
El programador modificó el código.
clase de demostración {public int div (int x, int y) lanza Fushuexception/*El resultado de lanzar o no lanzar es el mismo*/{if (y <0) {tirar nueva fushuexception ("El denominador tiene un número negativo ------/bu fushu", y); } return x/y; }} La clase Fushuexception extiende RuntimeException /*Heritance RuntimeException* /{fushuexception (string m, int value) {super (m); }} clase ExceptionDemo {public static void main (string args []) {demo d = new Demo (); int x = d.div (4, -3); /*La excepción aparecerá después de ejecutar esto, no habrá ningún problema con la compilación*/ system.out.println ("x ="+x); System.out.println ("Over"); }}Resultados de ejecución:
Excepción en el hilo "principal" Fushuexception: aparece un número negativo en el denominador ------/bu fushu
en Demo.Div (excepcionDemo.Java:7)
en ExceptionDemo.Main (excepcionDemo.java:26)
De los resultados anteriores, podemos ver:
Cuando la excepción personalizada: si se produce la excepción, la operación no se puede continuar.
Deje que la excepción personalizada herede RuntimeException.
Para excepciones, hay dos tipos:
1. Excepción detectada durante la compilación.
2. Excepción que no se detecta durante la compilación (excepción de tiempo de ejecución. RuntimeException y sus subclases)
El artículo anterior comprende de manera integral que el mecanismo de manejo de excepciones en Java es todo el contenido que he compartido con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.