¿Por qué Java no permite subclases genéricas de Throwable?

De acuerdo con Java Language Sepecification , 3ra edición:

Es un error en tiempo de compilación si una clase genérica es una subclase directa o indirecta de Throwable.

Deseo entender por qué se ha tomado esta decisión. ¿Qué hay de malo con las excepciones genéricas?

(Hasta donde yo sé, los genéricos son simplemente azúcar sintáctica en tiempo de compilación, y se traducirán de Objecttodos modos en los .classarchivos, por lo que declarar efectivamente una clase genérica es como si todo en ella fuera un Object. Corríjame si me equivoco .)

Como dijo Mark, los tipos no son reificables, lo cual es un problema en el siguiente caso:

try {
   doSomeStuff();
} catch (SomeException<Integer> e) {
   // ignore that
} catch (SomeException<String> e) {
   crashAndBurn()
}

Ambos SomeException<Integer>y SomeException<String>se borran al mismo tipo, no hay forma de que la JVM distinga las instancias de excepción y, por lo tanto, no hay forma de saber qué catchbloque debe ejecutarse.

Aquí hay un ejemplo simple de cómo usar la excepción:

class IntegerExceptionTest {
  public static void main(String[] args) {
    try {
      throw new IntegerException(42);
    } catch (IntegerException e) {
      assert e.getValue() == 42;
    }
  }
}

El cuerpo de la instrucción TRy arroja la excepción con un valor dado, que es captado por la cláusula catch.

Por el contrario, la siguiente definición de una nueva excepción está prohibida, ya que crea un tipo parametrizado:

class ParametricException<T> extends Exception {  // compile-time error
  private final T value;
  public ParametricException(T value) { this.value = value; }
  public T getValue() { return value; }
}

Un intento de compilar lo anterior informa un error:

% javac ParametricException.java
ParametricException.java:1: a generic class may not extend
java.lang.Throwable
class ParametricException<T> extends Exception {  // compile-time error
                                     ^
1 error

Esta restricción es sensata porque casi cualquier intento de detectar dicha excepción debe fallar, porque el tipo no es reificable. Uno podría esperar que un uso típico de la excepción sea algo como lo siguiente:

class ParametricExceptionTest {
  public static void main(String[] args) {
    try {
      throw new ParametricException<Integer>(42);
    } catch (ParametricException<Integer> e) {  // compile-time error
      assert e.getValue()==42;
    }
  }
}

Esto no está permitido, porque el tipo en la cláusula catch no es reificable. Al momento de escribir este artículo, el compilador de Sun informa una cascada de errores de sintaxis en tal caso:

% javac ParametricExceptionTest.java
ParametricExceptionTest.java:5: <identifier> expected
    } catch (ParametricException<Integer> e) {
                                ^
ParametricExceptionTest.java:8: ')' expected
  }
  ^
ParametricExceptionTest.java:9: '}' expected
}
 ^
3 errors

Como las excepciones no pueden ser paramétricas, la sintaxis está restringida, por lo que el tipo debe escribirse como un identificador, sin el siguiente parámetro.

Es esencialmente porque fue diseñado de mala manera.

Este problema impide un diseño abstracto limpio, por ejemplo,

public interface Repository<ID, E extends Entity<ID>> {

    E getById(ID id) throws EntityNotFoundException<E, ID>;
}

El hecho de que una cláusula catch no funcione para los genéricos no está justificado no es excusa para ello. El compilador podría simplemente no permitir tipos genéricos concretos que extiendan Throwable o no permitir los genéricos dentro de las cláusulas catch.

Los genéricos se verifican en tiempo de compilación para la corrección de tipo. La información de tipo genérico se elimina luego en un proceso llamado borrado de tipo . Por ejemplo, List<Integer>se convertirá al tipo no genérico List.

Debido a la eliminación de tipo , los parámetros de tipo no se pueden determinar en tiempo de ejecución.

Supongamos que tiene permiso para extenderse Throwableasí:

public class GenericException<T> extends Throwable

Ahora consideremos el siguiente código:

try {
    throw new GenericException<Integer>();
}
catch(GenericException<Integer> e) {
    System.err.println("Integer");
}
catch(GenericException<String> e) {
    System.err.println("String");
}

Debido a la eliminación de tipo , el tiempo de ejecución no sabrá qué bloque de captura ejecutar.

Por lo tanto, es un error en tiempo de compilación si una clase genérica es una subclase directa o indirecta de Throwable.

Fuente: problemas con el borrado de tipo

Esperaría que sea porque no hay forma de garantizar la parametrización. Considere el siguiente código:

try
{
    doSomethingThatCanThrow();
}
catch (MyException<Foo> e)
{
    // handle it
}

Como notará, la parametrización es solo azúcar sintáctico. Sin embargo, el compilador intenta asegurarse de que la parametrización permanezca consistente en todas las referencias a un objeto en el ámbito de compilación. En el caso de una excepción, el compilador no tiene forma de garantizar que MyException solo se arroje desde un ámbito que está procesando.