Catch all checked exceptions and turn into unchecked exception I am currently trying to learn Lambdas and following the book Java SE8 for the really Impatient and just finished Chapter 1 of it. This is the question, I am trying to get done with:


  Didn’t you always hate it that you had to deal with checked exceptions
  in a Runnable? Write a method uncheck that catches all checked
  exceptions and turns them into unchecked exceptions. For example,

new Thread(uncheck( () -&gt; { System.out.println("Zzz"); Thread.sleep(1000); })).start(); // Look, no catch (InterruptedException)!

  
  Hint: Define an
  interface RunnableEx whose run method may throw any exceptions. Then
  implement public static Runnable uncheck(RunnableEx runner). Use a
  lambda expression inside the uncheck function. Why can’t you just use
  Callable&lt;Void&gt; instead of RunnableEx?


This is my solution:

@FunctionalInterface
public interface RunnableEx extends Runnable {
    @Override
    default void run () {
        try {
            doRun();
        } catch (Error | RuntimeException e) {
            throw e;
        } catch (Throwable throwable) {
            throw new IndexOutOfBoundsException("IOBE");
        }
    }

    void doRun ()
        throws Throwable;
}


and

public class Question6 {
    public static void main (String... args) {
        uncheck(() -&gt; {
            System.out.println("Question6");
        });
    }

    public static Runnable uncheck (final RunnableEx runner) {
        final RunnableEx runnable = () -&gt; {
            try {
                runner.doRun();
            } catch (Error | RuntimeException e) {
                throw e;
            } catch (Throwable ignored) {
                runner.doRun();
            }
        };

        return runnable;
    }

    // We can not use Callable&lt;Void&gt; because it throws Checked Exception.
}


I request two things: 


How can this be improved, if it can be?
As per my understanding, this implementation seems to be correct, but is it really?
default void run () {


There should be no blank after a method name (neither in a declaration not in a call). There are only blanks after if and while to distinguish them visually from method calls.



    try {
        doRun();
    } catch (Error | RuntimeException e) {
        throw e;
    } catch (Throwable throwable) {
        throw new IndexOutOfBoundsException("IOBE");
    }


Really IndexOutOfBoundsException??? What index, what bounds? It should be

    try {
        doRun();
    } catch (Error | RuntimeException e) {
        throw e;
    } catch (Throwable e) {
        throw new RuntimeException(e);
    }


It's called exception wrapping. You can't throw e, so you wrap it into a RuntimeException and it can be obtained via getCause. Printing the stack does it, so you lose no information.



    final RunnableEx runnable = () -&gt; {
        try {
            runner.doRun();
        } catch (Error | RuntimeException e) {
            throw e;
        } catch (Throwable ignored) {
            runner.doRun();
        }
    };


The line runner.doRun() makes no sense to me. It failed, so you do it again. Why?

Moreover, it may throw a Throwable.

Moreover, you're repeating what you did above.

You've been already given a workable example in the question:

new Thread(uncheck( () -&gt; { System.out.println("Zzz"); Thread.sleep(1000); })).start(); // Look, no catch (InterruptedException)!