Capturando uma exceção e repetindo-a, mas não é uma exceção

Eu me deparei com código parecido com isto:

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

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

Esse código me surpreende porque parece que o run()-method é capaz de lançar um Exception, já que ele captura Exceptione o repete novamente, mas o método não está declarado para lançar Exceptione aparentemente não precisa ser. Esse código compila perfeitamente (pelo menos no Java 11).

Minha expectativa seria que eu tivesse que declarar throws Exceptionno run()método

Informação extra

De maneira semelhante, se doSomethingfor declarado como lançado, IOExceptionele só IOExceptionprecisará ser declarado no run()método-, mesmo que Exceptionseja capturado e reapresentado.

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

Questão

Java geralmente gosta de clareza, qual é a razão por trás desse comportamento? Sempre foi assim? O que na especificação da linguagem Java permite que o run()método não precise declarar throws Exceptionnos trechos de código acima? (Se eu adicionar, o IntelliJ me avisa que Exceptionnunca é lançado).

Como não fiz a varredura JLScomo você fez na sua pergunta, leve essa resposta com um grão de sal. Eu queria fazer um comentário, mas teria sido muito grande.

Às vezes, acho engraçado como javacé "inteligente" em alguns casos (como no seu caso), mas deixa muitas outras coisas para serem tratadas mais tarde JIT. Nesse caso, é apenas que o compilador "pode ​​dizer" que apenas um RuntimeExceptionseria capturado. Isso é óbvio, é a única coisa que você joga doSomething. Se você alterar ligeiramente o seu código para:

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

você verá um comportamento diferente, porque agora javacpode dizer que há um novo Exceptionque você está lançando, não relacionado ao que você pegou.

Mas as coisas estão longe do ideal, você pode "enganar" o compilador novamente através de:

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

OMI, por causa ex2 = ex;disso, não deve falhar novamente, mas falha.

Caso isso tenha sido compilado com javac 13+33