En Java, se puede try ... catchcapturar cualquier declaración que pueda generar una excepción. Coloque las declaraciones que pueden causar excepciones en try { ... }el medio y luego use catch para capturar las correspondientes Exceptiony sus subclases.
Múltiples declaraciones de captura
catchSe pueden utilizar varias declaraciones, cada una de las cuales catchcaptura la Exceptionclase correspondiente y sus subclases. JVMDespués de que se detecte la excepción, catchla declaración se comparará de arriba a abajo. Después de que se encuentre una determinada coincidencia , catchse ejecutará catchel bloque de código y luego la coincidencia no continuará.
En pocas palabras: catchsolo se puede ejecutar una de varias declaraciones. Por ejemplo:
public static void main(String[] args) {
try {
process1();
process2();
process3();
} catch (IOException e) {
System.out.println(e);
} catch (NumberFormatException e) {
System.out.println(e);
}
}
Cuando hay más catchde uno, catchel orden es muy importante: primero se debe escribir la subclase. Por ejemplo:
public static void main(String[] args) {
try {
process1();
process2();
process3();
} catch (IOException e) {
System.out.println("IO error");
} catch (UnsupportedEncodingException e) {
// 永远捕获不到
System.out.println("Bad encoding");
}
}
Para el código anterior, UnsupportedEncodingExceptionla excepción nunca se captura porque es IOExceptionuna subclase de . Cuando se lanza una excepción UnsupportedEncodingException, será catch (IOException e) { ... }capturada y ejecutada.
Por lo tanto, la forma correcta de escribir es poner la subclase al frente:
public static void main(String[] args) {
try {
process1();
process2();
process3();
} catch (UnsupportedEncodingException e) {
System.out.println("Bad encoding");
} catch (IOException e) {
System.out.println("IO error");
}
}
finallyDeclaración
Independientemente de si se produce una excepción, si queremos ejecutar algunas declaraciones, como la limpieza, ¿cómo escribir?
Puede escribir la instrucción de ejecución varias veces: coloque las que se ejecutan normalmente tryy catchescriba cada una de nuevo. Por ejemplo:
public static void main(String[] args) {
try {
process1();
process2();
process3();
System.out.println("END");
} catch (UnsupportedEncodingException e) {
System.out.println("Bad encoding");
System.out.println("END");
} catch (IOException e) {
System.out.println("IO error");
System.out.println("END");
}
}
System.out.println("END");El código anterior ejecutará esta instrucción independientemente de si se produce una excepción .
Entonces, ¿cómo eliminar estos códigos duplicados? Java的try ... catchEl mecanismo también proporciona finallysentencias, finallybloques de sentencias que se garantiza que se ejecutarán con o sin errores. El código anterior se puede reescribir de la siguiente manera:
public static void main(String[] args) {
try {
process1();
process2();
process3();
} catch (UnsupportedEncodingException e) {
System.out.println("Bad encoding");
} catch (IOException e) {
System.out.println("IO error");
} finally {
System.out.println("END");
}
}
Tenga en cuenta que finallyhay varias características:
finallyLas sentencias no son obligatorias y pueden escribirse o no,
finallysiempre se ejecutan en último lugar.
Si no ocurre ninguna excepción, el bloque de instrucciones se ejecuta normalmente try { ... }y luego se ejecuta finally. Si ocurre una excepción, interrumpa la ejecución del try { ... }bloque de instrucciones, luego salte para ejecutar el bloque de instrucciones catch correspondiente y finalmente ejecútelo finally.
Se puede ver que finallyse usa para asegurar que se debe ejecutar algún código.
En algunos casos, puede no haber ninguno catch, solo use try ... finallyla estructura. Por ejemplo:
void process(String file) throws IOException {
try {
...
} finally {
System.out.println("END");
}
}
Debido a que el método declara las excepciones que pueden generarse, no es necesario escribir catch.
Atrapar múltiples excepciones
Si la lógica de procesamiento de algunas excepciones es la misma, pero la excepción en sí no tiene una relación de herencia, entonces debe escribir varias cláusulas de captura:
public static void main(String[] args) {
try {
process1();
process2();
process3();
} catch (IOException e) {
System.out.println("Bad input");
} catch (NumberFormatException e) {
System.out.println("Bad input");
} catch (Exception e) {
System.out.println("Unknown error");
}
}
Dado que el código para manejar IOExceptionla NumberFormatExceptionsuma es el mismo, podemos combinar los dos usos | juntos:
public static void main(String[] args) {
try {
process1();
process2();
process3();
} catch (IOException | NumberFormatException e) {
// IOException或NumberFormatException
System.out.println("Bad input");
} catch (Exception e) {
System.out.println("Unknown error");
}
}
resumen
Al usar try ... catch ... finally:
El orden de coincidencia de varias catchdeclaraciones es muy importante y las subclases deben colocarse primero;
finallyLa sentencia garantiza que se ejecutará con o sin excepción, es opcional;
Una catchdeclaración también puede coincidir con varias excepciones de no herencia.