Interfaces and Exceptions

Question

I just stumbled across something that's bothering me, as I don't know what would the be the best way to deal with the following situation:
interface Fooable {
  public void doSomething();
class Bar implements Fooable {
  public void doSomething() {
    // code that throws a checked exception here
}I could catch the exception, but then the caller of the interface might not notice that something went wrong. I could wrap the exception in a RuntimeException, but then nobody calling the interface would notice that such an exception might occur. I could change the interface, but I don'�t ned to tell you what that means.
It's an ugly situation, alright, and nothing I have at hands, but something I thought about. What would you suggest to do in this case?
The problem could even be worse:
interface Fooable {
  public void doSomething() throws SomeCheckedException;
class Bar implements Fooable {
  public void doSomething() throws SomeCheckedException {
    // code that _DOES NOT_ throw a checked exception here
class Baz extends Bar {
  public void doSomething() throws SomeCheckedException {
    // code that throws a checked exception here
}What now? Add code like if (false) throw new CheckedException();to Bar.doSomething() just to please the compiler? Bad choice.
Ugly situations with ugly solutions only, I guess.

Answer 1

I have a suggestion. Not sure it is wise - I will leave others to comment on this approach:
import java.io.IOException;
public class Test {
    public static interface Worker {
        public void work(String s);
    public static interface Unsafe {
        public Exception getFault();
    public static class SafeWorker implements Worker {
        public void work(String s) {
            doSomethingSafe(s);
        public void doSomethingSafe(String s) {
            System.out.println(s);
    public static class UnsafeWorker implements Unsafe, Worker {
        private Exception _e;
        public void work(String s) {
            try {
                doSomethingUnsafe(s);
            } catch (IOException e) {
                _e = e;
        public Exception getFault() { return _e; }
        public void doSomethingUnsafe(String s) throws IOException {
            if (s.equals("crash")) {
                throw new IOException(s);
            System.out.println(s);
    public static void main(String[] args) {
        Worker[] workers = {
            new SafeWorker(),
            new UnsafeWorker()
        for (int i = 0; i < workers.length; i++) {
            Worker worker = workers;
doWork(worker, "fine");
doWork(worker, "crash");
public static void doWork(Worker w, String s) {
w.work(s);
if (w instanceof Unsafe) {
Exception e = ((Unsafe) w).getFault();
if (e != null) {
System.out.println("fault found");
e.printStackTrace();
What this means is the original Worker interface does not need changing. Some implementations of worker may cause checked exceptions to be thrown and caught. A new interface 'Unsafe' is created. Any class that implements this interface indicates that its implementations are unsafe, and must be verified by checking in the getFault method returns null? Some (myself included) might consider this approach a bit of a hack ;-) Comments appreciatated.
Cheers, Neil