Mientras probaba la función de captura múltiple que encontré en mi método m1() , todo funciona bien como se esperaba.
Sin embargo, en m2() no se compila el mismo código. Acabo de cambiar la sintaxis para reducir el número de líneas de código.
public class Main { public int m1(boolean bool) { try { if (bool) { throw new Excep1(); } throw new Excep2(); //This m1() is compiling abs fine. } catch (Excep1 | Excep2 e) { return 0; } } public int m2(boolean b) { try { throw b ? new Excep1() : new Excep2(); //This one is not compiling. } catch (Excep1 | Excep2 e) { return 0; } } private static interface I { } private static class Excep1 extends Exception implements I { } private static class Excep2 extends Exception implements I { } } ¿Por qué no se compila el método m2() ?
El tipo de expresión
b ? new Excep1() : new Excep2() es Exception , ya que ese es el supertipo común de Excep1 y Excep2 .
Sin embargo, no está detectando Exception , por lo que el compilador se queja de ello.
Si detecta Exception , pasará la compilación:
public int m2(boolean b) { try { throw b ? new Excep1() : new Excep2(); } catch (Exception e) { return 0; } }Traté de encontrar la entrada JLS que explica el tipo de expresión ternaria condicional en su ejemplo.
Todo lo que pude encontrar fue que esta expresión en particular es 15.25.3. Expresión condicional de referencia .
No estoy del todo seguro de si cuenta como una poliexpresión o una expresión independiente. Creo que es independiente (ya que las expresiones poli involucran un contexto de asignación o un contexto de invocación, y no creo que una declaración de throw cuente como ninguno de esos).
Para una expresión independiente: "Si los operandos segundo y tercero tienen el mismo tipo (que puede ser el tipo nulo), entonces ese es el tipo de la expresión condicional".
En su caso, los operandos segundo y tercero tienen tres tipos comunes: Object , Throwable y Exception ; el tipo de expresión debe ser uno de los dos últimos, ya que "La expresión en una instrucción throw debe indicar una variable o un valor de un tipo de referencia que es asignable (§5.2) al tipo Throwable".
Parece que el compilador elige el tipo común más específico ( Exception ) y, por lo tanto, una catch (Exception e) resuelve el error de compilación.
También traté de reemplazar sus dos excepciones personalizadas con dos subclases de IOException , en cuyo caso catch (IOException e) resuelve el error de compilación.
Estás confundiendo al compilador con esta línea:
throw b ? new Excep1() : new Excep2();El compilador ve que el resultado de la expresión (a la derecha del lanzamiento) es la superclase común entre Except1 y Except2, que es Exception y, por lo tanto, el tipo efectivo que está lanzando se convierte en Exception. La declaración de captura no puede detectar que está tratando de lanzar Excep1 o Except2.
Java lo restringe para capturar o declarar todos los tipos de excepción que el método puede lanzar,
Busca padres comunes para ambas (/todas) Excepciones y espera que las atrape o declare como lanzamientos, por ejemplo, si Excep1 extiende Throwable , tendrá que atrapar también Throwable
En el primer caso, Java está seguro de que está lanzando Excep1 o Excep2