Por que o Java não permite subclasses genéricas de Throwable?

De acordo com o Java Language Sepecification , 3ª edição:

É um erro em tempo de compilação se uma classe genérica for uma subclasse direta ou indireta de Throwable.

Desejo entender por que essa decisão foi tomada. O que há de errado com exceções genéricas?

(Até onde eu sei, os genéricos são simplesmente açúcar sintático em tempo de compilação e serão traduzidos de Objectqualquer maneira nos .classarquivos, declarar com eficiência uma classe genérica é como se tudo nela fosse um Object. Por favor, corrija-me se estiver errado .)

Como mark disse, os tipos não são passíveis de devolução, o que é um problema no seguinte caso:

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

Ambos SomeException<Integer>e SomeException<String>são apagados para o mesmo tipo, não há como a JVM distinguir as instâncias de exceção e, portanto, não há como saber qual catchbloco deve ser executado.

Aqui está um exemplo simples de como usar a exceção:

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

O corpo da instrução TRy lança a exceção com um determinado valor, que é capturado pela cláusula catch.

Por outro lado, a seguinte definição de uma nova exceção é proibida, pois cria um 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; }
}

Uma tentativa de compilar o que foi mencionado acima relata um erro:

% 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

Essa restrição é sensata porque quase qualquer tentativa de capturar essa exceção deve falhar, porque o tipo não é reificável. Pode-se esperar que um uso típico da exceção seja algo como o seguinte:

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;
    }
  }
}

Isso não é permitido, porque o tipo na cláusula catch não é reificável. No momento da redação deste artigo, o compilador Sun reporta uma cascata de erros de sintaxe nesse caso:

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

Como as exceções não podem ser paramétricas, a sintaxe é restrita, de modo que o tipo deve ser gravado como um identificador, sem o seguinte parâmetro.

É essencialmente porque foi projetado de uma maneira ruim.

Esse problema impede o design abstrato limpo, por exemplo,

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

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

O fato de uma cláusula catch falhar para genéricos não é reificado não é desculpa para isso. O compilador pode simplesmente proibir tipos genéricos concretos que estendem Throwable ou desautorizar genéricos dentro de cláusulas catch.

Os genéricos são verificados no momento da compilação quanto à correção do tipo. As informações de tipo genérico são removidas em um processo chamado apagamento de tipo . Por exemplo, List<Integer>será convertido para o tipo não genérico List.

Por causa do apagamento do tipo , os parâmetros do tipo não podem ser determinados em tempo de execução.

Vamos supor que você tenha permissão para estender Throwableassim:

public class GenericException<T> extends Throwable

Agora vamos considerar o seguinte código:

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

Devido ao apagamento do tipo , o tempo de execução não saberá qual bloco de captura executar.

Portanto, é um erro em tempo de compilação se uma classe genérica for uma subclasse direta ou indireta de Throwable.

Fonte: Problemas com apagamento de tipo

Eu esperaria que seja porque não há como garantir a parametrização. Considere o seguinte código:

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

Como você observa, a parametrização é apenas açúcar sintático. No entanto, o compilador tenta garantir que a parametrização permaneça consistente em todas as referências a um objeto no escopo da compilação. No caso de uma exceção, o compilador não tem como garantir que MyException seja lançada apenas de um escopo que está processando.