1. ¿Qué es una excepción?
Primero, echemos un vistazo al ejemplo de la figura a continuación:
En este ejemplo, el código de error existe dividiendo por 0. Excepción debido a dividir por 0: ArithmeticException
HelloException.java
paquete com.yiibai.tutorial.exception; public class HelloException {public static void main (string [] args) {System.out.println ("tres"); // esta división no hay problema. valor int = 10/2; System.out.println ("dos"); // esta división no hay problema. valor = 10/1; System.out.println ("uno"); // Esta división tiene un problema, dividido por 0. // Se ha producido un error aquí. valor = 10/0; // y el siguiente código no se ejecutará. System.out.println ("¡Vamos!"); }}Ejecutar este ejemplo dará como resultado:
Puede ver notificaciones en la pantalla de la consola. Las notificaciones de error son muy claras, incluida la información sobre las líneas de código.
Echemos un vistazo al siguiente programa a través del proceso en la figura a continuación:
Modificaremos el código de la realización mencionada anteriormente.
Hellocatchexception.java
paquete com.yiibai.tutorial.Exception; public class HELOCACTEXCECECION {public static void main (string [] args) {system.out.println ("tres"); // esta división no hay problema. valor int = 10/2; System.out.println ("dos"); // esta división no hay problema. valor = 10/1; System.out.println ("uno"); Pruebe {// Esta división tiene un problema, dividido por 0. // Se ha producido un error aquí. valor = 10/0; // y el siguiente código no se ejecutará. System.out.println ("value =" + value); } catch (arithmeticException e) {// El código en el bloque de captura se ejecutará System.out.println ("Error:" + E.getMessage ()); // El código en el bloque Catch se ejecutará System.out.println ("Ignorar ..."); } // Este código se ejecuta system.out.println ("¡vamos!"); }}Ejecutando los resultados de la muestra:
Tres
Dos
Uno
Error: / por cero
Ignorar...
¡Vamos!
Explicaremos el siguiente procedimiento de la siguiente manera al flujo de la imagen de ejemplo.
2. Jerarquía de excepción <Br /> Este es un modelo del gráfico jerárquico de las excepciones de Java.
La clase más alta es:
Las dos subclases directas son errores y excepción.
Hay una subclase RuntimeException en la transferencia de excepciones, incluidas las excepciones de tiempo de compilación que no se verifican en Java. Verifique y cancele el cheque en el momento de la compilación, como se describe en la siguiente sección del ejemplo de implementación.
Nota: Su clase debe heredar de dos ramas: error o excepción, no directamente de Throwable.
La máquina virtual plantea este error cuando falla un enlace dinámico, o cuando se produce alguna otra falla "dura" de la máquina virtual. Los programas típicos de Java no captan errores, por lo que los programas Java no arrojan ningún error. La mayoría de los programas arrojan y capturan objetos derivados de la clase de excepción. Una excepción indica un problema, pero estos problemas no son problemas sistémicos graves. La mayoría de los programas que escriba lanzarán y atraparán excepciones.
La clase de excepción define muchas subclases en el paquete Java. Estas subclases indican que pueden ocurrir diferentes tipos de excepciones. Por ejemplo, negativeRearraSizeException indica que el programa está tratando de crear una matriz de tamaño negativo.
Un significado especial de la subclase de un director en el idioma Java: la clase RuntimeException representa una excepción que ocurre (durante el tiempo de ejecución) en una máquina virtual Java. Un ejemplo de una excepción de tiempo de ejecución es la excepción de NullyiibaierException, que se plantea cuando un método intenta acceder a un miembro de un objeto a través de una referencia nula. NullyiibaierException puede aparecer en cualquier lugar donde un programa intente desreferir un objeto. Los beneficios de verificar la captura de excepción frecuentemente superan sus costos.
Dado que las excepciones de tiempo de ejecución son omnipresentes, es inútil intentar atrapar o especificar todo el tiempo (código ilegible y no mantenible), el compilador permite que las excepciones de tiempo de ejecución no sean capacitados y especifique.
El paquete Java define varias clases de RuntimeException. Puedes ver estas excepciones, al igual que otras. Pero no hay necesidad de una forma de especificar que arroja una excepción de tiempo de ejecución. Además, puede crear su propia subclase RuntimeException. Excepciones de tiempo de ejecución: la siguiente discusión contiene una discusión en profundidad de cuándo y cómo usar excepciones de tiempo de ejecución. 3. Use la captura de prueba para manejar excepciones
Escriba clases heredadas de la excepción.
AgeException.java
paquete com.yiibai.tutorial.exception.basic; public class AgeException extiende la excepción {public EraException (String Message) {super (Mensaje); }} Tooyunungexception.javapackage com.yiibai.tutorial.exception.basic; public class Tooyunungexception extiende AgeException {public tooyunungexception (mensaje de cadena) {super (mensaje); }} ToooldException.java
paquete com.yiibai.tutorial.exception.basic; public class ToooldException extiende AgeException {public TooOldException (string Message) {super (Mensaje); }} Y el método estático para verificar la clase de edad para la clase Ageutils.
Edadutils.java
Paquete com.yiibai.tutorial.exception.basic; public class Ageutils {// Este método verifica la edad. // Si la edad es inferior a 18 años, el método lanzará una excepción a Tooyunungexception // Si la edad mayor de 40, el método lanzará una excepción demasiado a lo largo de la Excepción pública de verificación estática (int Age) lanza TooyunungeXception, ToooldException {if (edad <18) {// Si la edad es menor que 18, una excepción se arrojará // este método termina aquí. tirar nueva tooyunungexception ("edad" + edad + "demasiado joven"); } else if (edad> 40) {// Si la edad mayor de 40, se lanzará una excepción. // Este método termina aquí. tirar nueva ToooldException ("edad" + edad + "demasiado vieja"); } // Si la edad es entre 18 y 40. // Este código se ejecutará. System.out.println ("edad" + edad + "ok!"); }} Verifique las excepciones y las excepciones sin control:
AgeException es una excepción, la subclase de ToooldException y TooyunungeXception2 son subclases directas de AgeException, por lo que son "excepción verificada"
El método Ageutil.Checkage (int) ha lanzado una excepción y necesita enumerar sus declaraciones de método a través de la palabra clave "lanzamientos". O puedes declarar lanzar más niveles.
La ubicación de Ageutil.Checkage (INT) también debe procesarse para captar la excepción o continuar lanzándola.
"Excepción verificada" se verifica por "Java Compiler".
Hay dos opciones:
Trycatchdemo1.java
paquete com.yiibai.tutorial.exception.basic; public class TryCatchDemo1 {public static void main (string [] args) {system.out.println ("comenzar a reclutar ..."); // verifique la edad System.out.println ("Verifique su edad"); int Age = 50; intente {ageutils.checkage (edad); System.out.println ("¡PASAS!"); } Catch (TooyunungeXception e) {// Haz algo aquí .. System.out.println ("¡Eres demasiado joven, no pases!"); System.out.println (e.getMessage ()); } Catch (TooLoLeException e) {// Haz algo aquí .. System.out.println ("¡Eres demasiado viejo, no pases!"); System.out.println (e.getMessage ()); }}} En el siguiente ejemplo, captaremos la excepción (clase HyperException) a través de la clase principal.
Trycatchdemo2.java
paquete com.yiibai.tutorial.exception.basic; public class TryCatchDemo2 {public static void main (string [] args) {system.out.println ("comenzar a reclutar ..."); // verifique la edad System.out.println ("Verifique su edad"); int Age = 15; Pruebe {// aquí puede lanzar ToooldException o tooyunungexception ageutil.eckage (edad); System.out.println ("¡PASAS!"); } Catch (AgeException e) {// Si se produce una excepción, tipo de AgeException // Este bloque de captura se ejecutará System.out.println ("Su edad inválida, no pasa"); System.out.println (e.getMessage ()); }}} También se pueden agrupar diferentes excepciones en bloques para manejar si se manejan de la misma manera al programa lógico.
Trycatchdemo3.java
paquete com.yiibai.tutorial.exception.basic; public class TryCatchDemo3 {public static void main (string [] args) {system.out.println ("comenzar a reclutar ..."); // verifique la edad System.out.println ("Verifique su edad"); int Age = 15; Pruebe {// aquí puede lanzar ToooldException o tooyunungexception ageutil.eckage (edad); System.out.println ("¡PASAS!"); } Catch (TooyunungeXception | ToooldException e) {// Catch Multi excepciones en un bloque. System.out.println ("Su edad inválida, no pasa"); System.out.println (e.getMessage ()); }}} 4. Try-Catch-Finalmente
Estamos acostumbrados a captar errores a través de bloques de prueba de prueba. Try-Catch-Finalmente para manejar las excepciones por completo.
Pruebe {// Haz algo aquí} Catch (Exception1 E) {// Haz algo aquí} Catch (Exception2 E) {// Haz algo aquí} Finalmente {// Finalmente el bloque siempre se ejecuta // haz algo aquí} TryCatchFinallyDemo.java
paquete com.yiibai.tutorial.exception.basic; public class TryCatchFinallyDemo {public static void main (string [] args) {string text = "001234a2"; int value = toInteger (texto); System.out.println ("value =" + value); } public static int toInteger (texto de cadena) {try {System.out.println ("Comenzar el texto de parse:" + texto); // Una excepción puede lanzar aquí (numberFormateException). int value = Integer.ParseInt (texto); valor de retorno; } Catch (NumberFormateException e) {// en el caso de 'texto' no es un número. // se ejecutará este bloque de captura. System.out.println ("Excepción de formato de número" + E.getMessage ()); // Devuelve 0 si NumberFormateException ocurre return 0; } Finalmente {System.out.println ("End de texto de parse:" + texto); }}}Este es el proceso del programa. El bloque Finalmente siempre se ejecutará bajo cualquier circunstancia.
5. Excepción circundante
Persona.java
paquete com.yiibai.tutorial.exception.wrap; public class Person {public static final String macho = "masculino"; Cadena final estática pública femenina = "femenina"; nombre de cadena privada; género de cadena privada; edad privada int; persona pública (nombre de cadena, género de cadena, int age) {this.name = name; this.gender = género; this.age = edad; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } public String getGender () {return gender; } public void setGender (String Gender) {this.gender = gender; } public int getAge () {return Age; } public void setAge (int Age) {this.age = edad; }} Genderexception.java
paquete com.yiibai.tutorial.exception.wrap; // excepción de género.public class gendereRexception extiende la excepción {public genteRexception (string Message) {super (mensaje); }} El paquete de clase ValidateException tiene otras excepciones.
ValidateException.java
paquete com.yiibai.tutorial.exception.wrap; public class ValidateException extiende la excepción {// envolver una excepción public validateException (excepción e) {super (e); }} ValidateUtils.java
paquete com.yiibai.tutorial.exception.wrap; import com.yiibai.tutorial.exception.basic.ageutils; public class validateUtils {public static void Checkperson (persona persona) arroja validateException {try {// verificar la edad. // Válido si entre 18-40 // este método puede lanzar ToooldException, TooyunungeXception. AgeUtils.Checkage (persona.getage ()); } Catch (Exception e) {// Si no es válido // envuelve esta excepción por ValidateException, y tira una nueva ValidateException (e); } // Si esa persona es mujer, es decir, inválida. if (persona.getGender (). Equals (Person.female)) {GendereRexception e = new GendereRexception ("No acepte mujeres"); tirar nueva ValidateException (E); }}} WrapperexceptionDemo.java
paquete com.yiibai.tutorial.exception.wrap; public class wrapperexceptionDemo {public static void main (string [] args) {// un reclutamiento de participante. Persona persona = nueva persona ("casarse", persona. Female, 20); Prueba {// Las excepciones pueden ocurrir aquí. ValidateUtils.Checkperson (persona); } Catch (ValidateException Wrap) {// Obtener la causa real. // puede ser tooyunungexception, toooldException, genderexception excepción causa = (excepción) wrap.getCause (); if (causa! = null) {system.out.println ("no pasar, causa:" + causa.getMessage ()); } else {System.out.println (wrap.getMessage ()); }}}}6. RuntimeException y subclases La clase RuntimeException y sus subclases son "excepciones sin control". El compilador Java no lo verifica en el momento de la compilación. En algunos casos, puede heredar de esta rama para escribir sus propias excepciones.
A continuación se presentan algunas clases que pertenecen a la rama RuntimeException (por supuesto, esto no es todo).
Algunos ejemplos de excepciones de manejo de este tipo:
6.1- nullyibaierexception
Esta es la excepción más común y generalmente causa errores en el programa. La excepción se lanza cuando llama a un método o accede al campo de un objeto vacío.
Nullyiibaierexceptiondemo.java
paquete com.yiibai.tutorial.exception.runtime; clase pública nullyibaierExceptionDemo {// Por ejemplo, aquí hay un método que puede devolver la cadena nula. public static string getString () {if (1 == 2) {return "1 == 2 !!"; } return null; } public static void main (string [] args) {// Este es un objeto que hace referencia no es nulo. String text1 = "Hello Exception"; // Llamar al método recupera la longitud de la cadena. int longitud = text1.length (); System.out.println ("longitud text1 =" + longitud); // Este es un objeto que hace referencia a NULL. String text2 = getString (); // Llamar al método recupera la longitud de la cadena. // NullyiibaierException ocurrirá aquí. // es una excepción que ocurre en tiempo de ejecución (tipo de runtimeException) // el compilador Javac no lo obliga a usar un bloque de intento para manejarlo longitud = text2.length (); System.out.println ("¡Finalizar!"); }}Resultados de ejecutar el ejemplo:
En realidad, Try-Catch se puede usar para atrapar y manejar esta excepción, como al manejar otras excepciones. Sin embargo, esto es mecánico y generalmente debemos verificar para asegurarnos de que el objeto no sea nulo antes de usarlo.
Puede corregir el código anterior para que sea similar al siguiente para evitar excepciones de puntero nulo:
// Este es un objeto nulo.String text2 = getString (); // verificar para asegurarse de que 'text2' no sean null.// en lugar de usar try-catch.if (text2! = Null) {longitud = text2.length ();} 6.2- ArrayIndexOfBoundException
Esta excepción ocurre cuando intenta acceder a un elemento de matriz con un índice no válido. Por ejemplo, una matriz tiene 10 elementos para acceder, pero está accediendo a elementos con el índice 20.
ArrayIndexofBoundsexceptionDemo.java
paquete com.yiibai.tutorial.exception.runtime; public class ArrayInDexofBoundSexceptionDemo {public static void main (string [] args) {string [] strs = new String [] {"one", "dos", "tres"}; // El acceso al elemento tiene índice 0. String str1 = strs [0]; System.out.println ("String At 0 =" + Str1); // El acceso al elemento tiene índice 5. // ArrayIndexOfBoundSException ocurre aquí. Cadena str2 = strs [5]; System.out.println ("String At 5 =" + Str2); }} Para evitar ArrayIndexOfBoundsexception, deberíamos ser más sobre verificar la matriz que usar Try-Catch.
if (strs.length> 5) {string str2 = strs [5]; System.out.println ("String At 5 =" + Str2);} else {System.out.println ("No hay elementos con índice 5");}Lo anterior se trata de este artículo, espero que sea útil para el aprendizaje de todos.