Java为什么不允许Throwable的通用子类？

根据Java语言分隔，第3版：

如果泛型类是的直接子类或间接子类，则是编译时错误Throwable。

我想理解为什么做出这个决定。通用异常有什么问题？

（据我所知，泛型只是编译时的语法糖，Object无论如何它们都将转换为.class文件，因此有效地声明泛型类就好像其中的所有内容都是Object。。如果我错了，请更正我）

正如标记所说，类型是不可更改的，在以下情况下会出现问题：

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

两者SomeException<Integer>和SomeException<String>都被擦除为相同的类型，JVM无法区分异常实例，因此也无法确定catch应执行哪个块。

这是有关如何使用异常的简单示例：

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

TRy语句的主体抛出具有给定值的异常，该异常由catch子句捕获。

相反，禁止对新异常进行以下定义，因为它会创建参数化类型：

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

尝试编译以上内容会报告错误：

% 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

这种限制是明智的，因为几乎所有捕获此类异常的尝试都必须失败，因为类型是不可更改的。可能有人会期望该异常的典型用法如下所示：

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

这是不允许的，因为catch子句中的类型不可更改。在撰写本文时，Sun编译器在这种情况下报告了一系列语法错误：

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

因为异常不能是参数化的，所以语法受到限制，因此必须将类型写为标识符，并且不带任何后续参数。

实质上是因为它的设计方式不好。

此问题阻止了干净的抽象设计，例如，

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

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

catch子句对泛型失败的事实没有得到证实，这不是借口。编译器可以简单地禁止扩展Throwable的具体泛型类型，也可以禁止catch子句中的泛型。

泛型在编译时检查类型正确性。然后，在称为类型擦除的过程中删除通用类型信息。例如，List<Integer>将转换为非泛型类型List。

由于类型擦除，因此无法在运行时确定类型参数。

假设允许您这样扩展Throwable：

public class GenericException<T> extends Throwable

现在让我们考虑以下代码：

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

由于类型为Erase，运行时将不知道要执行哪个catch块。

因此，如果泛型类是Throwable的直接或间接子类，则这是编译时错误。

资料来源： 类型擦除问题

我希望这是因为没有办法保证参数化。考虑以下代码：

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

如您所述，参数化只是语法糖。但是，编译器试图确保参数化在编译范围内对对象的所有引用中保持一致。在发生异常的情况下，编译器无法保证仅从其正在处理的范围中引发MyException。