Tại sao Java không cho phép các lớp con chung của throwable?

Theo Thông báo ngôn ngữ Java , ấn bản thứ 3:

Đó là lỗi thời gian biên dịch nếu một lớp chung là lớp con trực tiếp hoặc gián tiếp Throwable.

Tôi muốn hiểu tại sao quyết định này đã được đưa ra. Có gì sai với ngoại lệ chung?

(Theo như tôi biết, thuốc generic chỉ đơn giản là đường cú pháp thời gian biên dịch và chúng sẽ được dịch sang Objectbất kỳ .classtệp nào, do đó, việc khai báo một lớp chung là như thể mọi thứ trong đó là một Object. Xin hãy sửa cho tôi nếu tôi sai .)

Như đã nói, các loại không thể xác định lại, đây là một vấn đề trong trường hợp sau:

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

Cả hai SomeException<Integer>và SomeException<String>bị xóa cùng một loại, JVM không có cách nào để phân biệt các trường hợp ngoại lệ và do đó không có cách nào để biết catchkhối nào sẽ được thực thi.

Đây là một ví dụ đơn giản về cách sử dụng ngoại lệ:

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

Phần thân của câu lệnh TRy đưa ra ngoại lệ với một giá trị đã cho, được bắt bởi mệnh đề bắt.

Ngược lại, định nghĩa sau đây về một ngoại lệ mới bị cấm, bởi vì nó tạo ra một loại tham số:

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

Một nỗ lực để biên dịch các báo cáo ở trên một lỗi:

% 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

Hạn chế này là hợp lý bởi vì hầu hết mọi nỗ lực để bắt một ngoại lệ như vậy đều phải thất bại, vì loại này không thể áp dụng được. Người ta có thể mong đợi một cách sử dụng ngoại lệ điển hình là một cái gì đó như sau:

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

Điều này là không được phép, bởi vì loại trong mệnh đề bắt không thể áp dụng lại. Tại thời điểm viết bài này, trình biên dịch Sun báo cáo một loạt các lỗi cú pháp trong trường hợp như vậy:

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

Vì các ngoại lệ không thể là tham số, cú pháp bị hạn chế sao cho loại phải được viết dưới dạng định danh, không có tham số nào sau đây.

Về cơ bản là vì nó được thiết kế theo cách xấu.

Vấn đề này ngăn chặn thiết kế trừu tượng sạch, ví dụ,

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

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

Việc một điều khoản bắt sẽ thất bại đối với thuốc generic không được thống nhất là không có lý do cho điều đó. Trình biên dịch đơn giản có thể không cho phép các loại chung chung cụ thể mở rộng các tổng quát có thể ném hoặc không cho phép trong các mệnh đề bắt.

Generics được kiểm tra tại thời gian biên dịch cho độ chính xác của loại. Thông tin loại chung sau đó được loại bỏ trong một quá trình gọi là loại xóa . Ví dụ, List<Integer>sẽ được chuyển đổi sang loại không chung chung List.

Do xóa kiểu , tham số loại không thể được xác định tại thời gian chạy.

Giả sử bạn được phép gia hạn Throwablenhư thế này:

public class GenericException<T> extends Throwable

Bây giờ hãy xem xét các mã sau đây:

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

Do xóa kiểu , bộ thực thi sẽ không biết khối bắt nào sẽ thực thi.

Do đó, đó là lỗi thời gian biên dịch nếu một lớp chung là lớp con trực tiếp hoặc gián tiếp của throwable.

Nguồn: Vấn đề với loại tẩy

Tôi hy vọng rằng đó là vì không có cách nào để đảm bảo tham số hóa. Hãy xem xét các mã sau đây:

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

Như bạn lưu ý, tham số hóa chỉ là đường cú pháp. Tuy nhiên, trình biên dịch cố gắng đảm bảo rằng tham số hóa vẫn nhất quán trên tất cả các tham chiếu đến một đối tượng trong phạm vi biên dịch. Trong trường hợp ngoại lệ, trình biên dịch không có cách nào để đảm bảo rằng MyException chỉ được ném từ một phạm vi mà nó đang xử lý.