Catturare un'eccezione e riproporla, ma non è un'eccezione

Mi sono imbattuto in codice simile a questo:

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

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

Questo codice mi sorprende perché sembra che il run()metodo sia in grado di lanciare un Exception, dal momento che lo cattura Exceptione lo ricodifica, ma il metodo non è dichiarato da lanciare Exceptione apparentemente non è necessario. Questo codice viene compilato correttamente (almeno in Java 11).

La mia aspettativa sarebbe che avrei dovuto dichiarare throws Exceptionnel run()metodo.

Ulteriori informazioni

In modo simile, se doSomethingviene dichiarato di buttare IOExceptionallora solo IOExceptionbisogno di essere dichiarato nel run()-Metodo, anche se Exceptionviene catturato e rilanciati.

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

Domanda

Java di solito ama la chiarezza, qual è la ragione di questo comportamento? È sempre stato così? Cosa nelle specifiche del linguaggio Java consente al run()metodo di non dover dichiarare throws Exceptionnei frammenti di codice sopra? (Se lo aggiungessi, IntelliJ mi avverte che Exceptionnon viene mai lanciato).

Non ho esaminato JLScome hai fatto nella tua domanda, quindi per favore prendi questa risposta con un granello di sale. Volevo fare un commento, ma sarebbe stato troppo grande.

Trovo divertente a volte, come javacè piuttosto "intelligente" in alcuni casi (come nel tuo caso), ma lascia molte altre cose da gestire in seguito JIT. In questo caso, è solo che il compilatore "può dire" che solo un RuntimeExceptionverrebbe catturato. Questo è ovvio, è l'unica cosa da buttare dentro doSomething. Se modifichi leggermente il codice in:

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

vedrai un comportamento diverso, perché ora javacpuoi dire che c'è un nuovo Exceptionche stai lanciando, non correlato a quello che hai catturato.

Ma le cose sono tutt'altro che ideali, puoi "ingannare" nuovamente il compilatore tramite:

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

IMO, a causa ex2 = ex;sua non dovrebbe fallire di nuovo, ma lo fa.

Nel caso in cui questo è stato compilato javac 13+33