Uso de la sentencia try

Uso de la sentencia try
Ahora que ya sabe lo que son excepciones , vamos a explorar cómo manejarlos . Java
utiliza un try
declaración de separar la lógica que podría lanzar una excepción de la lógica de manejar
que
excepción. La figura 6.2 muestra la sintaxis de una sentencia try .
FIGURA 6 . 2 La sintaxis de una sentencia try
El código en el bloque try se ejecuta normalmente. Si cualquiera de los estados lanzar
una excepción
que pueden ser capturados por el tipo de excepción que figuran en el bloque catch , el
bloque try deja de funcionar
y la ejecución pasa a la sentencia catch . Si ninguna de las declaraciones en el bloque try
lanzar una excepción que puede ser capturado , la cláusula catch no se ejecuta .
Usted probablemente ha notado la palabra "bloqueo " y " cláusula " que se utiliza
indistintamente. los
examen hace esto así , por lo que están consiguiendo que utilizó para ello. Ambos son
correctos. " Bloque" es
correcta porque hay apoyos presentes . " Cláusula " es correcta , ya que son parte de una
declaración de tratar .
No hay un montón de reglas de sintaxis aquí . Se requieren las llaves para la oportunidad
y
bloques catch .
En nuestro ejemplo , la niña se levanta por sí misma la primera vez que cae . Esto es lo
que esta
parece:
3: void explore() {
4: try {
5: fall();
6: System.out.println("never get here");
7: } catch (RuntimeException e) {
8: getUp();
9: }
10: seeAnimals();
11: }
12: void fall() { throw new RuntimeException(); }
En primer lugar, la línea 5 llama al método caída ( ) . La línea 12 inicia una excepción .
Esto significa Java
salta directamente al bloque catch , saltándose la línea 6. La chica se levanta en la línea
8. Ahora el intento
declaración es una y la ejecución continúa normalmente con la línea 10 .
Ahora vamos a ver algunas declaraciones try no válidos que el examen podría tratar de
engañarlo con .
¿Ves lo que está mal con éste?
try // DOES NOT COMPILE
fall();
catch (Exception e)
System.out.println("get up");
The problem is that the braces are missing. It needs to look like this:
try {
fall();
} catch (Exception e) {
System.out.println("get up");
}
las sentencias try son como los métodos en que las llaves se requieren incluso si sólo hay
un estado de cuenta dentro de los bloques de código . si las declaraciones y los bucles
son especiales en este sentido como
que le permiten omita las llaves .
¿Qué tal este?
try {// DOES NOT COMPILE
fall();
}
Este código no compilará porque el bloque try no tiene nada después de ella.
Recuerde , la punta de una sentencia try es algo que sucede si una excepción es
lanzado. Sin otra cláusula, la sentencia try es solitario .
Ahora que sabes lo básico , vamos a empezar a añadir más características a excepciones
. El seguimiento
secciones que muestran cómo agregar una cláusula finalmente a una sentencia try y
capturar diferentes
tipos de excepciones y describen lo que sucede si se produce una excepción en el catch o
finally .
Adición de un bloque finally
La sentencia try también le permite ejecutar código al final con una cláusula fi nalmente
sin tener en cuenta
si se produce una excepción . La figura 6.3 muestra la sintaxis de una sentencia try con
este
funcionalidad adicional.
FIGURA 6 . 3 La sintaxis de una sentencia try con finally
Hay dos caminos a través de código con tanto una captura y un fin . Si una excepción
se lanza , el bloque finally se ejecuta después de que el bloque catch . Si no es una
excepción es lanzada , la
Por último bloque se ejecuta después del bloque try se completa .
Volvamos a nuestro ejemplo niña , esta vez con último:
12: void explore() {
13: try {
14: seeAnimals();
15: fall();
16: } catch (Exception e) {
17: getHugFromDaddy();
18: } finally {
19: seeMoreAnimals();
20: }
21: goHome();
22: }
La chica cae en la línea 15. Si se levanta por sí misma , el código pasa al bloque finally
y se ejecuta la línea 19. A continuación, la sentencia try ha terminado y el código avanza
en la línea 21. Si el
chica no se levanta por sí misma, se produce una excepción . Las carreras de bloque de
captura y ella recibe una
abrazo en la línea 17. A continuación, la sentencia try ha terminado y el código avanza en
la línea 21. De cualquier manera ,
el final es el mismo . El bloque finally se ejecuta y termina la sentencia try .
En el examen OCA , una sentencia try debe tener los productos y / o finalmente .
Habiendo tanto está muy bien. Que ni tiene un problema . En el examen de OCP , se le
aprender sobre una sintaxis especial para una sentencia try try- llamada con - recursos
que permite una captura ni tampoco un bloque finally . En el examen OCA , se obtiene
para asumir una sentencia try es sólo una sentencia try regular y no una trywithdeclaración recursos.
El examen tratará de engañar al que le faltan las cláusulas o cláusulas en el orden
equivocado . Hacer
que se ve por qué el siguiente hacer o no compilar ?
25: try { // DOES NOT COMPILE
26: fall();
27: } finally {
28: System.out.println("all better");
29: } catch (Exception e) {
30: System.out.println("get up");
31: }
32:
33: try { // DOES NOT COMPILE
34: fall();
35: }
36:
37: try {
38: fall();
39: } finally {
40: System.out.println("all better");
41: }
El primer ejemplo (líneas 25-31 ) no se compila porque la captura y , finalmente, los
bloques
están en el orden equivocado . El segundo ejemplo ( líneas 33-35 ) no se compila porque
hay
debe haber una trampa o bloque finally . El tercer ejemplo ( líneas 37-41 ) es sólo multa .
captura no se ha
Por último es necesario si está presente .
Un problema con finalmente es que cualquier uso realistas para que están fuera del
alcance de la
examen de OCA . finalmente, se suele utilizar para cerrar los recursos tales como
archivos o bases de datos , tanto de
los cuales son los temas del examen de OCP . Esto significa que la mayoría de los
ejemplos que encuentras en el
examen con OCA finalmente se va a parecer artificial . Por ejemplo , usted conseguirá
Preguntas
tales como qué este código salidas :
String s = "";
try {
s += "t";
} catch(Exception e) {
s += "c";
} finally {
s += "f";
}
s += "a";
System.out.print(s);
La respuesta es TFA . Se ejecuta el bloque try . Dado que se lanza ninguna excepción ,
Java va
directamente al bloque finally . A continuación, se ejecuta el código después de la
instrucción try . Sabemos; esta
es un ejemplo tonto . Esperar a ver ejemplos de este tipo en el examen de OCA .
System.exit
Hay una excepción al " bloque finally siempre se ejecuta después de que el bloque catch "
regla:
Java defi ne un método que se llama como System.exit ( 0 ) ;. El parámetro es el número
entero
código de error que es retornada . System.exit dice Java, "Stop . Terminar el programa en
este momento .
No pase ir. No se debe recoger de $ 200. " Cuando System.exit se le llama en el try o captura
bloque, finalmente no se ejecuta .
La captura de varios tipos de excepciones
Hasta ahora , usted ha sido la captura de un solo tipo de excepción. Ahora vamos a ver lo
que sucede
cuando diferentes tipos de excepciones pueden ser lanzadas desde el mismo método .
Creación de sus propias excepciones no está en el examen de OCA , pero es en el
examen de OCP .
Sin embargo , el examen OCA puede defi ne excepciones básicas que le muestre la
jerarquía . Solo
hay que hacer dos cosas con esta información . En primer lugar , debe ser capaz de
reconocer si el
excepción es una excepción o no facturado . En segundo lugar, es necesario determinar
si alguno de
las excepciones son subclases de los otros.
class AnimalsOutForAWalk extends RuntimeException { }
class ExhibitClosed extends RuntimeException { }
class ExhibitClosedForLunch extends ExhibitClosed { }
En este ejemplo, hay tres excepciones personalizadas . Todos son excepciones sin
marcar
ya que directa o indirectamente se extienden RuntimeException . Ahora cogemos los dos
tipos de
excepciones y manejarlas imprimiendo el mensaje apropiado :
public void visitPorcupine() {
try {
seeAnimal();
} catch (AnimalsOutForAWalk e) {// first catch block
System.out.print("try back later");
} catch (ExhibitClosed e) {// second catch block
System.out.print("not today");
}
}
Existen tres posibilidades para cuando se ejecuta este código. Si seeAnimal ( ) no
produce una
excepción, no se imprime nada . Si el animal es a dar un paseo , sólo el bloque catch
primero
carreras. Si la muestra está cerrado , sólo el segundo bloque catch se ejecuta .
Existe una regla para el orden de los bloques catch . Java mira en el orden en que
Aparecer. Si es imposible que uno de los bloques de captura para ser ejecutado, un error
del compilador
sobre el código inalcanzable se produce . Esto sucede cuando una superclase es
capturado antes de una subclase .
Recuerde, nosotros advertimos que prestar atención a las excepciones de las subclases .
En el ejemplo puercoespín , el orden de los bloques catch podría revertirse debido a que
el
excepciones no heredan el uno del otro . Y sí , hemos visto un puercoespín ser tomado
por un
caminar con una correa .
El ejemplo siguiente muestra los tipos de excepciones que no heredan el uno del otro :
public void visitMonkeys() {
try {
seeAnimal();
} catch (ExhibitClosedForLunch e) {// subclass exception
System.out.print("try back later");
} catch (ExhibitClosed e) {// superclass exception
System.out.print("not today");
}
}
Si se produce la excepción c ExhibitClosedForLunch más específi , el primer retén fi
el bloque se ejecuta . Si no es así , Java comprueba si la superclase ExhibitClosed
excepción es lanzada
y lo coge . Esta vez , el orden de los bloques catch sí importa. En el reverso se hace
no trabajo.
public void visitMonkeys() {
try {
seeAnimal();
} catch (ExhibitClosed e) {
System.out.print("not today");
} catch (ExhibitClosedForLunch e) {// DOES NOT COMPILE
System.out.print("try back later");
}
}
Esta vez, si la excepción c ExhibitClosedForLunch más específi es lanzada , la captura
bloque para ExhibitClosed corre - que significa que no hay forma de que el segundo
bloque de captura de
jamás ejecutar . Java nos dice correctamente hay un bloque catch inalcanzable .
Vamos a probar esto una vez más. ¿Ves por qué este código no se compila ?
public void visitSnakes() {
try {
seeAnimal();
} catch (RuntimeException e) {
System.out.print("runtime exception");
} catch (ExhibitClosed e) {// DOES NOT COMPILE
System.out.print("not today");
} catch (Exception e) {
System.out.print("exception");
}
}
Es el mismo problema . ExhibitClosed es un RuntimeException . Si se tira , los primeros
bloque catch se encarga de ello , asegurándose de que no hay manera de llegar al
segundo bloque catch .
Para revisar la captura de múltiples excepciones , recuerda que a lo sumo un bloque
catch se ejecutará
y será el bloque catch primera que puede manejarlo.
Lanzando una segunda excepción
Hasta ahora , nos hemos limitado a una sentencia try en cada ejemplo . Sin embargo,
una captura o, finalmente, el bloque puede tener cualquier código Java válido en ella,
incluyendo otra
declaración de tratar .
A pesar de que el tema de la lectura de archivos es en el examen OCP , el examen OCA
puede preguntarle acerca de la manipulación con esas clases de excepción. Esto es
realmente una
regalo. Cuando vea una pregunta, usted sabe que el problema tiene que ser sobre
la sintaxis de Java básico o el manejo de excepciones !
El siguiente código intenta leer un expediente :
16: public static void main(String[] args) {
17: FileReader reader = null;
18: try {
19: reader = read();
20: } catch (IOException e) {
21: try {
22: if (reader != null) reader.close();
23: } catch (IOException inner) {
24: }
25: }
26: }
27: private static FileReader read() throws IOException {
28: // CODE GOES HERE
29: }
El caso más sencillo es si la línea 28 no produce una excepción. A continuación, toda la
captura en el bloque
líneas 20-25 se omiten. A continuación, considere si la línea 28 lanza una
NullPointerException. Eso no es
una IOException, por lo que el bloque catch en las líneas 20-25 todavía se omitirán.
Si la línea 28 hace lanzar una IOException, el bloque catch en las líneas 20-25 se pone de
ejecución. Línea
22 intenta cerrar el lector. Si eso va bien, el código se completa y el método main ()
termina normalmente. Si el método close () hace una excepción, Java busca de más
capturas
bloques. No hay ninguno, por lo que el principal método que lanza nueva excepción.
Independientemente, el
excepción en la línea 28 se maneja. Una excepción diferente podría ser lanzado, pero la
de
la línea 28 se hace.
La mayoría de los ejemplos que se ven con el manejo de excepciones en el examen son
abstractas. Ellos
usar letras o números para asegurarse de que entiende el fl ujo. Éste muestra que sólo el
la última excepción de que se lance asuntos. (Esto es cierto para el examen OCA. Se va a
cambiar un poco en
el examen OCP).
26: try {
27: throw new RuntimeException();
28: } catch (RuntimeException e) {
29: throw new RuntimeException();
30: } finally {
31: throw new Exception();
32: }
La línea 27 se produce una excepción , que está atrapado en la línea 28. El bloque catch
a continuación, lanza
una excepción en la línea 29. Si no hubiera un bloque finally , a excepción de la línea 29
lo haría
ser lanzado . Sin embargo, el bloque finally se ejecuta después del bloque try . Desde el
bloque finally
emite una excepción de su propia en la línea 31 , éste se tira . La excepción de la
bloque catch se olvidado. Por esta razón, a menudo se ve otro try / catch dentro de una
finally - para asegurarse de que no enmascara la excepción del bloque catch .
A continuación vamos a mostrar el ejemplo más duro puede estar relacionado con pedido
excepciones. ¿Qué te parece este método devuelve ? Ir lentamente. Es complicado.
30: public String exceptions() {
31: String result = "";
32: String v = null;
33: try {
34: try {
35: result += "before";
36: v.length();
37: result += "after";
38: } catch (NullPointerException e) {
39: result += "catch";
40: throw new RuntimeException();
41: } finally {
42: result += "finally";
43: throw new Exception();
44: }
45: } catch (Exception e) {
46: result += "done";
47: }
48: return result;
49: }
La respuesta correcta es la captura antes de finalmente hacer. Todo es normal hasta la
línea
35 , cuando " antes " , se añade. Línea 36 lanza una NullPointerException . Línea 37 se
omite
como Java va directamente al bloque catch . La línea 38 hace detectar la excepción , y "
captura " es
añadido en la línea 39. A continuación, la línea 40 tiros un RuntimeException . Las
carreras por último bloque después
la captura , independientemente de si se produce una excepción ; que añade "por fin" al
resultado. en este
punto , hemos completado la instrucción try interior que corrió en las líneas 34-44 . La
captura externa
bloque ve entonces una excepción fue arrojado y lo atrapa en la línea 45 ; Añade " hecho"
para dar como resultado .