Edit Question - KnowledgeHub

Title Body

I have a fairly detailed question about the right way to wrap a checked exception, and the way that Guava does it. (Apologies for the length but I want to get my thought process down) The standard Runnable interface looks like this: public interface Runnable { public void run(); } where run() can't throw a checked exception. So if I want to have a Runnable which is used to wrap tasks which throw checked exceptions, and I intend to have the thing that calls Runnable.run() handle those exceptions, rather than in Runnable.run() itself, I have to wrap the exception in an unchecked exception. So for a while I was using: Runnable r = new Runnable { @Override public void run() { try { doNastyStuff(); } catch (NastyException e) { throw new RuntimeException(e); } } }; and then I can handle RuntimeException in an upper level. Except then I figured, that what I really want is to handle a wrapped exception separately, since I know its semantics are to wrap a checked exception, so I wrote this helper class: /** * Wrapped exception: the purpose of this is just to wrap another exception, * and indicate that it is a wrapped exception */ public class WrappedException extends RuntimeException { /** * @param t any throwable */ public WrappedException(Throwable t) { super(t); } } and then I can do this: /* place that produces the exception */ ... catch (NastyException e) { throw new WrappedException(e); } ... /* upper level code that calls Runnable.run() */ try { ... SomeOtherNastyCode(); r.run(); ... } catch (SomeOtherNastyException e) { logError(e); } catch (WrappedException e) { logError(e.getCause()); } and it seems to

Tags (comma-separated) Cancel