使用新检查的异常覆盖Java接口

Question

Suppose in Java, I'm using a preexisting interface that is rather general

public interface Generator {
    public String generate();
}

and I have my own class

public class FromFileGenerator implements Generator {
    ...
    public String generate() throws FileNotFoundException {
        String output = //read from some file
        return file;
    }
}

The Java compiler yells at me because the implementation of generate() contains an exception not specified in the original signature (FileNotFoundException). However, clearly the exception does not belong in the interface, but it also cannot be neglected in the implementing class. How can this be resolved without simply failing silently?

Answer 1

You cannot add a checked exception to the declaration of a method that hides, overrides, or implements another method. You will need to catch the exception within the method and do something else with it (such as return null , or throw an unchecked exception, possibly wrapping the checked exception).

From the Java Language Specification, §8.4.8.3 :

A method that overrides or hides another method, including methods that implement abstract methods defined in interfaces, may not be declared to throw more checked exceptions than the overridden or hidden method.

Answer 2

Unfortunately, there is no way to resolve it nicely: exception specifications are part of the interface, so if someone who programs to your Generator interface is not expecting to see FileNotFoundException , it shouldn't be coming to them when they use FromFileGenerator .

A common way to resolve it is by introducing a common exception, and wrapping FileNotFoundException in it:

public class GeneratorException extends Exception {
    public GeneratorException(Exception inner) {
        super(inner);
    }
}
public interface Generator {
    public String generate() throws GeneratorException;
}
public class FromFileGenerator implements Generator {
...
    public String generate() throws GeneratorException {
        try {
            String output = //read from some file
            return file;
        } catch (FileNotFoundException fnf) {
            throw new GeneratorException(fnf);
        }
    }
}

Answer 3

Interface is a contract .

So you need to define that upfront.

So you can either do a try, catch within your method body or modify the contract.

Answer 4

You can wrap the implementation exception in an unchecked exception and throw that:

public class FromFileGenerator implements Generator {
    ...
    public String generate() {
        try {
            String output = //read from some file
            return file;
        } catch (IOException ioe) {
            throw new RuntimeException(ioe);
        }
    }
}

Answer 5

A common solution to this is to wrap the exception in an unchecked exception. So your class might look something like:

public class FromFileGenerator implements Generator {
    ...
    public String generate() throws FileNotFoundException {
        try {
            String output = //read from some file
            return output
        } catch (FileNotFoundException e) {
            throw new IllegalStateException(e);
        }
    }
}

Even better would be to change the interface to have its own checked exception. Then you could convert from FileNotFoundException to that checked exception in the same way that you convert to the unchecked IllegalStateException above.