Las excepciones de método deben lanzarse hacia arriba. ¿Cuál es el uso de la palabra clave throws para declarar posibles excepciones? ¿Para quién es? ¿Compilador o humano?
En las aplicaciones Java, existen dos métodos para manejar excepciones: manejar excepciones y declarar excepciones.
Manejo de excepciones: probar, detectar y finalmente
Para detectar excepciones, debe agregar un bloque de controlador de excepciones al código. Esta estructura Java puede contener tres partes,
con palabras clave Java. El siguiente ejemplo utiliza la estructura de código try-catch-finally.
1Importar Java.io.*;
2Clase pública EchoInputTryCatchFinally {
3 public static void main(String args[]){
4 System.out.println("Ingrese el texto que se repetirá:");
5 InputStreamReader ISR = new InputStreamReader(system . in);
6 lector de entrada con búfer = nuevo lector almacenado en búfer (ISR);
7 prueba {
8 línea de entrada de cadena = lector de entrada();
9 sistema .println. (" Leer:"+línea de entrada);
10 }
11 catch(io excepción exc){
12 System.out.println ("Excepción encontrado:"+exc);
13 }
14Finalmente {
15 sistema . out . println(" Fin.");
16 }
17 }
18}
Estos incluyen:
Bloque de prueba: cuando se colocan una o cuando se colocan varias declaraciones en try, significa que estas declaraciones pueden generar excepciones. El compilador sabe que puede ocurrir una excepción, por lo que utiliza una estructura especial para evaluar todas las declaraciones del bloque.
Bloque catch: cuando ocurre un problema, una opción es definir un bloque de código para manejar el problema, ese es el propósito del bloque catch. El bloque catch es el receptor de excepciones generadas por el bloque try. El principio básico es que una vez que ocurre una excepción, la ejecución del bloque try se detendrá y la JVM buscará la JVM correspondiente.
Bloque finalmente: también puede definir un bloque finalmente, y el código de este bloque se ejecutará independientemente del resultado de ejecutar el código del bloque de prueba. En todas las circunstancias comunes, se ejecutará el bloque finalmente. Se ejecutará un bloque finalmente independientemente de si el bloque try se ejecuta por completo, si se genera una excepción o no y si se maneja en un bloque catch o no.
Reglas try-catch-final:
Se debe agregar un bloqueo catch o finalmente después del intento. El bloque Try puede ir seguido de los bloques catch y finalmente, pero debe haber al menos un bloque.
Se debe seguir el orden de los bloques: si su código usa tanto el bloque catch como el bloque finalmente, el bloque catch debe colocarse después del bloque try.
El bloque catch está relacionado con el tipo de la clase de excepción correspondiente.
Un bloque try puede tener múltiples bloques catch. Si es así, se ejecuta el primer bloque coincidente.
Estructura try-catch-final encajable.
En la estructura try-catch-finally, la excepción se puede lanzar nuevamente.
Siempre termina con las siguientes situaciones: terminación prematura de la JVM (llamando a system.exit(int)); una excepción no controlada en el bloque finalmente;
Declarar una excepción
Para declarar una excepción, se debe agregar al final del bloque de firma del método. El siguiente es un ejemplo:
public void errorProneMethod(int input) throws java.io.IOException {
//El código del método, incluidos uno o más métodos
//Llamadas que pueden generar IOException
}
De esta manera, la excepción declarada se pasará al llamador del método, y el compilador también será informado de cualquier Los llamadores del método deben seguir las reglas de procesamiento o declaración. Las reglas para declarar excepciones son las siguientes:
Debe declarar cualquier excepción marcada que el método pueda generar.
Las excepciones no marcadas no son obligatorias y pueden declararse o no.
Los métodos de llamada deben seguir las reglas para manejar y declarar excepciones detectables. Si anula un método, no puede declarar una excepción diferente a la del método anulado. Cualquier excepción declarada debe ser de la misma clase o subclase que la excepción declarada por el método primordial.
Volver al principio
Clasificación del manejo de excepciones de Java
Las excepciones de Java se pueden dividir en excepciones detectables, excepciones no detectadas y excepciones personalizadas.
Excepciones detectables
El compilador verifica las excepciones detectables, lo que aplicará reglas de manejo o declaración para cualquier método que arroje una excepción. Por ejemplo, sqlExecption es una detección Llegó de manera anormal. Cuando se conecta a JDBC, si no detecta esta excepción, el compilador fallará y no permitirá la compilación.
Excepciones no detectadas
Las excepciones no detectadas no siguen reglas de manejo o declaración. Cuando se genera una excepción de este tipo, no es necesario tomar ninguna medida adecuada y el compilador no comprueba si dicha excepción se ha resuelto. Por ejemplo, si la longitud de la matriz es 3, cuando se utiliza el subíndice 3, se producirá una excepción de subíndice de matriz fuera de límites. La JVM no detectará esta excepción, depende del programador juzgarla. Hay dos clases principales que definen excepciones no comprobadas: RuntimeException y Error.
La subclase de error es una anomalía no detectada porque es imposible predecir cuándo se generará. Si la aplicación Java se queda sin memoria, puede ocurrir un OutOfMemoryError en cualquier momento; la causa generalmente no es una llamada especial de la aplicación, sino la propia JVM. Además, los errores suelen indicar problemas graves que la aplicación no puede resolver.
La clase RuntimeException también es una excepción de no detección, porque las excepciones de tiempo de ejecución causadas por operaciones JVM comunes pueden ocurrir en cualquier momento, y dichas excepciones generalmente son causadas por operaciones específicas. Pero estas operaciones ocurren con frecuencia en aplicaciones Java. Por lo tanto, no están sujetos a reglas de verificación y procesamiento o declaración del compilador.
Excepciones personalizadas
Las excepciones personalizadas se utilizan para representar ciertos tipos de errores en una aplicación y proporcionar un nuevo significado a uno o más problemas que puedan surgir en el código. Puede mostrar la similitud de errores entre múltiples ubicaciones en el código, diferenciar entre uno o más errores que pueden ocurrir cuando el código se ejecuta con problemas similares o dar el significado específico de un grupo de errores en una aplicación. Por ejemplo, cuando se opera en una cola, pueden ocurrir dos situaciones: intentar eliminar un elemento cuando la cola está vacía; intentar agregar un elemento cuando la cola está llena. Debe personalizar dos excepciones para manejar ambos casos.
Principios y tabúes del manejo de excepciones de Java
Principios del manejo de excepciones de Java
Manejar tantas excepciones como sea posible.
Para manejar tantas excepciones como sea posible, considere declarar una excepción si las condiciones realmente no permiten manejar excepciones en su propio código. Evite manejar excepciones en su código y simplemente declarelas, lo cual es un enfoque incorrecto y dependiente.
Soluciones específicas para problemas específicos
Parte de la ventaja de la excepción es que puede proporcionar diferentes operaciones de procesamiento para diferentes tipos de problemas. La clave para un manejo eficaz de excepciones es identificar un escenario de falla específico y desarrollar comportamientos correspondientes específicos para resolver ese escenario. Para aprovechar al máximo las capacidades de manejo de excepciones, es necesario construir bloques de procesador específicos para tipos específicos de problemas.
Registro de excepciones que pueden afectar el funcionamiento de la aplicación.
Tome al menos algunas medidas permanentes para registrar excepciones que puedan afectar el funcionamiento de la aplicación. Lo ideal, por supuesto, es que el problema subyacente que causa la excepción se resuelva la primera vez. Sin embargo, independientemente del procedimiento de tratamiento, siempre se deben documentar los posibles problemas críticos. Aunque esta operación es sencilla, puede ayudarle a localizar la causa de problemas complejos en su aplicación en muy poco tiempo.
Traduzca las excepciones al contexto empresarial según la situación.
Para recibir notificaciones sobre problemas específicos de la aplicación, la aplicación debe convertirse a un formato diferente. El código es más fácil de mantener si las excepciones están representadas por estados específicos de la empresa. En cierto sentido, cada vez que se pasa una excepción a un contexto diferente (es decir, otra capa tecnológica), se debe transformar en una forma que tenga sentido para el nuevo contexto.
Tabúes en el manejo de excepciones de Java
Generalmente no ignorar las excepciones.
Una de las operaciones más peligrosas dentro de un bloque de manejo de excepciones es manejar excepciones sin notificación. Como se muestra en el siguiente ejemplo:
1 intente {
2 class .forname(" negocio . dominio . cliente "); >
4 catch(ClassNotFoundException exc){ }
A menudo puedes ver bloques de código similares en bloques de código. A algunas personas siempre les gusta escribir de manera simple y rápida bloques de procesador vacíos al codificar y "consolarse" afirmando que están listos para agregar el código de recuperación "más tarde", pero este "más tarde" resulta ser "indefinidamente".
¿Cuáles son las desventajas de este enfoque? Si esta excepción no tiene ningún impacto negativo en el resto de la aplicación, está bien. Pero a menudo este no es el caso y las excepciones alteran el estado de la aplicación. En este punto, ese código equivale a engañar a los demás.
Si esto tiene un ligero efecto, la aplicación puede comportarse de forma extraña. Por ejemplo, faltan los valores establecidos por la aplicación o la GUI no es válida. Si el problema es grave, la aplicación puede tener problemas importantes porque la excepción no registra el punto de falla original y es difícil de manejar, como NullPointerExceptions repetidas.
Si toma medidas para registrar las excepciones detectadas, es poco probable que encuentre este problema. De hecho, a menos que confirme que la excepción no tiene impacto en el resto del código, al menos regístrela. Además, no ignore el problema; de lo contrario, el riesgo es muy alto y tendrá consecuencias impredecibles más adelante.
No utilice bloques de manejo de excepciones primordiales.
Otro proceso peligroso es el procesador de mantas. La estructura básica del código es la siguiente:
1 try {
2 // …
3 }
4 catch ( excepción e) {
5 // …
6 }
Hay dos requisitos previos para usar bloques de manejo de excepciones anulados:
1 En el código solo hay un problema.
Esto puede ser cierto, pero aun así, no debe utilizar el manejo de excepciones primordial para detectar formas más específicas de excepciones.
2. Siempre es aplicable una única operación de recuperación.
Esto es casi absolutamente incorrecto. Casi no existe un enfoque único para abordar cualquier problema que surja.
Analiza qué pasará si escribes código como este. Mientras el método siga arrojando el conjunto esperado de excepciones, todo estará bien. Sin embargo, si se produce una excepción inesperada, no verá qué acción tomar. Cuando el controlador principal realiza la misma tarea para la nueva clase de excepción, solo ve los resultados del manejo de excepciones de forma indirecta. Si el código no imprime ni registra la declaración, no verá los resultados en absoluto.
Peor aún, cuando el código cambia, el controlador de anulación continuará actuando en todos los nuevos tipos de excepción, manejando todos los tipos de la misma manera.
Generalmente no convierta una excepción específica en una excepción más general.
Es un error convertir una excepción específica en una excepción más general. En términos generales, esto cancelará el contexto generado cuando se lanzó originalmente la excepción, lo que será más difícil de manejar cuando la excepción se pase a otras partes del sistema.
Vea los siguientes ejemplos:
1 intente {
2 //código propenso a errores
3 }
4 catch(IOException e ){
5 String msg = "¡Si no tenías un problema antes, ahora lo tendrás!";
6Lanza una nueva excepción (msg);
7 }
Debido a que no hay información sobre la excepción original, el bloque del procesador no puede determinar la causa del problema y no sabe cómo corregirlo.
No maneje excepciones evitables.
Para algunos tipos de excepciones, en realidad no es necesario manejarlos en absoluto. Por lo general, las excepciones de tiempo de ejecución entran en esta categoría. No es necesario recurrir al manejo de excepciones cuando se tratan problemas como punteros nulos o índices de datos.
Ejemplos de aplicación de manejo de excepciones de Java
Al definir la categoría del banco, si el monto del retiro es mayor que el saldo, se debe hacer una excepción.
Defina una clase de excepción, insuficienteFundsException. Se pueden hacer excepciones al método de retiro si el saldo es menor que el monto del retiro.
Cuando se maneja una excepción, al llamar a deshacer, por lo tanto, el método de deshacer debe declararse para generar una excepción y ser llamado por el método superior.
Clase de excepción:
Clase insuficiente FundsExceptionextiende excepción {
Banco privado excepbank//objeto bancario
Doble excepción privadaImporte//a ser Dinero extraído
Excepción de fondos insuficientes (cuenta bancaria, monto doble)
{ excepbank = ba
excepAmount = dAmount
}< / p>
Cadena pública excepMessage(){
String str= "El saldo es"+excepbank.balance
+ "\n"+"El retiro es"+excepAmount;
Cadena de retorno;
}
}//Clase de excepción
Categoría de banco:
Categoría de banco {
Saldo doble; //Monto del depósito
Banco (Saldo doble) { this.balance = Saldo;}
Depósito público no válido (Monto doble){
if(da mount & gt; 0.0)balance+= da mount;
}
Retiro público no válido (doble cantidad)
Lanzamientos excepción de fondos insuficientes {
if(saldo & lt; throws new
Excepción de fondos insuficientes (esto, da monto);
saldo = saldo-da monto;
}
public void showBalance(){
System.out.println("El saldo es"+(int)balance ));
}
}
Llamada frontal:
Demo de excepción de clase pública{
Principal vacío estático público (argumentos de cadena) []){
prueba{
banco ba = nuevo banco(50
ba .withdraw(100);
System.out.println("¡Retiro exitoso!");
}catch(Excepción de fondos insuficientes e) {
system out . /p>
sistema . println(e . excepciónmensaje());
}
}
}
Volver al principio
Resumen
En el desarrollo de software y el desarrollo de scripts de prueba utilizando el lenguaje Java, el manejo de excepciones de Java es un aspecto muy importante. Prestar atención al manejo de excepciones hará que el código que desarrolle sea más sólido y estable. Este artículo explica sistemáticamente los principios y métodos del manejo de excepciones de Java. Puede ayudar a los lectores a comprender el mecanismo de manejo de excepciones de Java con mayor claridad y utilizarlo de manera más flexible al desarrollar código.