Capturar una excepción y volver a lanzarla, pero no es una excepción

Me topé con un código que se veía así:

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

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

Este código me sorprende porque parece que el run()método-es capaz de arrojar un Exception, ya que lo atrapa Exceptiony luego lo vuelve a arrojar, pero no se declara que el método arroje Exceptiony aparentemente no es necesario. Este código se compila muy bien (en Java 11 al menos).

Mi expectativa sería que tendría que declarar throws Exceptionen el run()método-.

Información extra

De manera similar, si doSomethingse declara que se lanza, IOExceptionentonces solo se IOExceptiondebe declarar en el run()método-, aunque Exceptionse atrape y se vuelva a lanzar.

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

Pregunta

A Java generalmente le gusta la claridad, ¿cuál es la razón detrás de este comportamiento? ¿Siempre ha sido así? ¿Qué en la especificación del lenguaje Java permite que el run()método no necesite declarar throws Exceptionen los fragmentos de código anteriores? (Si quisiera agregarlo, IntelliJ me advierte que Exceptionnunca se tira).

No he escaneado las JLSpreguntas que ha hecho en su pregunta, así que tome esta respuesta con un grano de sal. Quería hacer un comentario, pero habría sido demasiado grande.

A veces me parece gracioso, cómo javaces bastante "inteligente" en algunos casos (como en su caso), pero deja muchas otras cosas para ser manejadas más adelante JIT. En este caso, es solo que el compilador "puede decir" que solo RuntimeExceptionse capturaría un. Esto es obvio, es lo único que arrojas doSomething. Si cambia ligeramente su código a:

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

verá un comportamiento diferente, porque ahora javacpuede decir que hay una nueva Exceptionque está lanzando, no relacionada con la que atrapó.

Pero las cosas están lejos de ser ideales, puede "engañar" al compilador una vez más a través de:

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

OMI, por ex2 = ex;eso no debería fallar nuevamente, pero lo hace.

Por si acaso esto fue compilado con javac 13+33