Attraper une exception et la renvoyer, mais ce n'est pas une exception

Je suis tombé sur un code ressemblant à ceci:

void run() {
    try {
        doSomething();
    } catch (Exception ex) {
        System.out.println("Error: " + ex);
        throw ex;
    }
}

void doSomething() {
    throw new RuntimeException();
}

Ce code me surprend car il semble que la run()méthode-soit capable de lancer un Exception, car il l'attrape Exceptionpuis le rejette, mais la méthode n'est pas déclarée pour lancer Exceptionet n'a apparemment pas besoin de l'être. Ce code se compile très bien (en Java 11 au moins).

Je m'attendrais à devoir déclarer throws Exceptiondans la run()méthode.

Informations supplémentaires

De la même manière, si doSomethingest déclaré pour lancer, IOExceptionil suffit IOExceptionde le déclarer dans la run()méthode -même s'il Exceptionest capturé et renvoyé.

void run() throws IOException {
    try {
        doSomething();
    } catch (Exception ex) {
        System.out.println("Error: " + ex);
        throw ex;
    }
}

void doSomething() throws IOException {
    // ... whatever code you may want ...
}

Question

Java aime généralement la clarté, quelle est la raison de ce comportement? A-t-il toujours été comme ça? Qu'est-ce qui, dans la spécification du langage Java, permet à la run()méthode de ne pas avoir à déclarer throws Exceptiondans les extraits de code ci-dessus? (Si je voudrais l'ajouter, IntelliJ m'avertit qu'il Exceptionn'est jamais jeté).

Je n'ai pas parcouru le JLScomme vous l'avez demandé dans votre question, alors veuillez prendre cette réponse avec un grain de sel. Je voulais en faire un commentaire, mais il aurait été trop gros.

Je trouve parfois drôle, comment javacest assez "intelligent" dans certains cas (comme dans votre cas), mais laisse beaucoup d'autres choses à gérer plus tard JIT. Dans ce cas, c'est juste que le compilateur "peut dire" que seul un RuntimeExceptionserait intercepté. C'est évident, c'est la seule chose que vous lancez doSomething. Si vous modifiez légèrement votre code en:

void run() {
    try {
        doSomething();
    } catch (Exception ex) {
        Exception ex2 = new Exception();
        System.out.println("Error: " + ex);
        throw ex2;
    }
}

vous verrez un comportement différent, car maintenant vous javacpouvez dire qu'il y a un nouveau Exceptionque vous lancez, sans rapport avec celui que vous avez attrapé.

Mais les choses sont loin d'être idéales, vous pouvez encore "tromper" le compilateur via:

void run() {
    try {
        doSomething();
    } catch (Exception ex) {
        Exception ex2 = new Exception();
        ex2 = ex;
        System.out.println("Error: " + ex);
        throw ex2;
    }
}

OMI, à cause de ex2 = ex;cela ne devrait pas échouer à nouveau, mais c'est le cas.

Juste au cas où cela a été compilé avec javac 13+33