How does trick with rethrow checked exceptions works from the point of view of Java language?

Question

I have encountered that I must catch all checked exceptions inside stream expresions. I have read very popular topic:

How can I throw CHECKED exceptions from inside Java 8 streams?
And there is answer which suugest following approach:
we have 3 strings: "java.lang.Object" "java.lang.Integer" "java.lang.Strin"

We want to load classes by name.
Thus we need to use Class#forName method
Class#forName java doc)

As you can see following method declaration contains

throws ClassNotFoundException

Thus if we use usual loop we need to write followig code:

public void foo() throws ClassNotFoundException {
    String arr[] = new String[]{"java.lang.Object", "java.lang.Integer", "java.lang.Strin"};
    for(String className:arr){
        Class.forName(className);
    }
}

lets try to rewrite it using streams:

 public void foo() throws ClassNotFoundException {
        String arr[] = new String[]{"java.lang.Object", "java.lang.Integer", "java.lang.Strin"};
        Stream.of(arr).forEach(Class::forName);
    }

compiler says that:

Error:(46, 32) java: incompatible thrown types java.lang.ClassNotFoundException in method reference

Ok, lets try to use approach from topic mentioned above:

we create following methods:

public static <T, E extends Exception> Consumer<T> rethrowConsumer(Consumer_WithExceptions<T, E> consumer) {
    return t -> {
        try {
            consumer.accept(t);
        } catch (Exception exception) {
            throwAsUnchecked(exception);
        }
    };
}

 @FunctionalInterface
 public interface Consumer_WithExceptions<T, E extends Exception> {
     void accept(T t) throws E;
 }

@SuppressWarnings("unchecked")
private static <E extends Throwable> void throwAsUnchecked(Exception exception) throws E {
    throw (E) exception;
}

And client code will looks like this:

public void foo() throws ClassNotFoundException {
        String arr[] = new String[]{"java.lang.Object", "java.lang.Integer", "java.lang.Strin"};
        Stream.of(arr).forEach(rethrowConsumer(Class::forName));
    }

I want to know how does it work. It is really unclear for me.

lets research rethrowConsumer:

public static <T, E extends Exception> Consumer<T> rethrowConsumer(Consumer_WithExceptions<T, E> consumer) {
    return t -> {
        try {
            consumer.accept(t);
        } catch (Exception exception) {
            throwAsUnchecked(exception);
        }
    };
}

and throwAsUnchecked signature look slike

private static <E extends Throwable> void throwAsUnchecked(Exception exception) throws E {

Please clarify this mess.

P.S.

I localized that magic happens inside throwAsUnchecked because following snippet correct

   public static <T, E extends Exception> Consumer<T> rethrowConsumer(Consumer_WithExceptions<T, E> consumer) {
        return t -> {
            try {
                throw new Exception();
            } catch (Exception exception) {
                throwAsUnchecked(exception);
            }
        };
    }

But following not

public static <T, E extends Exception> Consumer<T> rethrowConsumer(Consumer_WithExceptions<T, E> consumer) {
    return t -> {
        try {
            consumer.accept(t);
        } catch (Exception exception) {
            throw new Exception();
            //throwAsUnchecked(exception);
        }
    };
}

And just for the record: you only use "_" for SOME_CONSTANT. It doesnt go into any other kind of name. — GhostCat, Sep 05 '17 at 09:14
@GhostCat actually I can't understand why compiler interpret Throwable as RuntimeException — gstackoverflow, Sep 06 '17 at 09:15
That is to be found in the linked question I have in my answer. To be specific, you want to read this: https://stackoverflow.com/a/14039011/1531124 — GhostCat, Sep 06 '17 at 09:17

GhostCat · Accepted Answer · 2017-09-05T09:26:16.043

The Java compiler understands that Class.forName() throws a checked exception. And that needs to somehow be handled. But when catching that checked exception and making it look like it gets wrapped into a RuntimeException for example - you resolve the compilation problem. By taking away the "thing" that the compiler complains about.

Please note: the compiler does not understand that invoking throwAsUnchecked(exception) will always throw up. In other words: by making a method call here, there is actually no code inside that method body that must throw. Of course this doesn't change the runtime situation. In the end, there is still an exception thrown - and surprisingly not a RuntimeException, but an instance of ClassNotFoundException.

The core point is that <E extends Throwable> translates into a RuntimeException (for the compiler). And that part is explained here!

And because of that, the second version of foo() can be written like:

public void foo() { ...

there is no more need to declare throws ClassNotFoundException!

In other words: this approach works by "tricking" the compiler into thinking that the exception that gets thrown is an unchecked one. And that trick itself is rooted in generics/type-erasure.

The linked explanation covers the technical part of type erasure, in other words, the Java byte code. From the Java *language* point of view, you have just an *unchecked* operation which opens the possibility of resulting in *heap pollution*, a mismatch between the compile-time type and the actual runtime type, which includes the possibility to have a checked exception where the compile-time type is `RuntimeException`. So the actual runtime behavior is not a violation of the language specification. — Holger, Sep 07 '17 at 07:27

How does trick with rethrow checked exceptions works from the point of view of Java language?

P.S.

1 Answers1