Dlaczego Java nie zezwala na generyczne podklasy Throwable?

Według Java Language Sepecification , 3. edycja:

Jest to błąd czasu kompilacji, jeśli klasa ogólna jest bezpośrednią lub pośrednią podklasą klasy Throwable.

Chciałbym zrozumieć, dlaczego podjęto taką decyzję. Co jest nie tak z ogólnymi wyjątkami?

(O ile wiem, typy generyczne są po prostu cukrem składniowym w czasie kompilacji i zostaną przetłumaczone na Objecttakie .classpliki w plikach, więc efektywne zadeklarowanie klasy ogólnej jest tak, jakby wszystko w niej było Object. Popraw mnie, jeśli się mylę .)

Jak powiedział Mark, typy nie są reifable, co jest problemem w następującym przypadku:

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

Oba SomeException<Integer>i SomeException<String>są kasowane do tego samego typu, nie ma możliwości, aby maszyna JVM rozróżniła wystąpienia wyjątków, a zatem nie ma możliwości określenia, który catchblok powinien zostać wykonany.

Oto prosty przykład użycia wyjątku:

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

Treść instrukcji TRy zgłasza wyjątek z daną wartością, który jest przechwytywany przez klauzulę catch.

Natomiast poniższa definicja nowego wyjątku jest zabroniona, ponieważ tworzy sparametryzowany typ:

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

Próba skompilowania powyższego zgłasza błąd:

% 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

To ograniczenie jest rozsądne, ponieważ prawie każda próba przechwycenia takiego wyjątku musi się nie powieść, ponieważ typu nie można ponowić. Można by się spodziewać, że typowe użycie wyjątku będzie wyglądać następująco:

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

Jest to niedozwolone, ponieważ typu w klauzuli catch nie można ponowić. W chwili pisania tego tekstu kompilator Sun zgłasza kaskadę błędów składniowych w takim przypadku:

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

Ponieważ wyjątki nie mogą być parametryczne, składnia jest ograniczona, więc typ musi być zapisany jako identyfikator, bez następującego parametru.

Dzieje się tak zasadniczo dlatego, że został zaprojektowany w zły sposób.

Ten problem uniemożliwia czysty abstrakcyjny projekt, np.

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

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

Fakt, że klauzula catch zawiodłaby dla typów ogólnych, nie jest reifikowana, nie jest dla tego usprawiedliwieniem. Kompilator może po prostu zabronić konkretnych typów ogólnych, które rozszerzają Throwable lub nie zezwalać na typy ogólne wewnątrz klauzul catch.

Typy generyczne są sprawdzane w czasie kompilacji pod kątem poprawności typu. Informacje o typie ogólnym są następnie usuwane w procesie zwanym wymazywaniem typu . Na przykład List<Integer>zostanie przekonwertowany na typ nieogólny List.

Ze względu na wymazywanie typu nie można określić parametrów typu w czasie wykonywania.

Załóżmy, że możesz rozszerzyć w Throwableten sposób:

public class GenericException<T> extends Throwable

Rozważmy teraz następujący kod:

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

Ze względu na wymazywanie typu środowisko wykonawcze nie będzie wiedział, który blok catch wykonać.

Dlatego jest to błąd czasu kompilacji, jeśli klasa ogólna jest bezpośrednią lub pośrednią podklasą Throwable.

Źródło: problemy z wymazywaniem typu

Spodziewałbym się, że to dlatego, że nie ma możliwości zagwarantowania parametryzacji. Rozważ następujący kod:

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

Jak zauważyłeś, parametryzacja to tylko cukier syntaktyczny. Jednak kompilator próbuje zapewnić spójność parametryzacji we wszystkich odwołaniach do obiektu w zakresie kompilacji. W przypadku wyjątku kompilator nie ma możliwości zagwarantowania, że ​​MyException jest wyrzucany tylko z zakresu, który przetwarza.