Interface methods with Exceptions

Question

I have an interface like the following
public interface FooInterface
     void doMethod() throws Exception;
}I've created a class which implements the interface
public class BarClass implements FooInterface
     public void doMethod()
          // Code...
}Why is it that when I compile the class, no warnings or compiler errors are generated when the exception reference is absent. When I change the signature of the class method to become..
public void doMethod() throws ExceptionThe compiler error that appears is...
doMethod() in BarClass cannot implement doMethod() in FooInterface; overridden method does not throw java.lang.Exception
I'm confused. I recall seeing the opposite. That is, aren't compiler errors generated when I fail to add the exception to the implemented method in the class...Isn't that necessary to comply with the contract specified by the interface..

Answer 1

When you implement an interface (or override amethod in a parent class)
you can declare that you throw a narrower set ofexceptions--including
none--because that doesn't violate the interface's(or parent class')
promise not to throw more than that exception.Then the interface will define only "as bad as things
could be" (struggling for words here) but will not
impose requirements on the class to alert calling
methods that the exception could be thrown.Yes, the interface is declaring a "things will be no worse than this" promise, but the method still has to declare any unchecked exceptions that it could throw. If the interface says throws FooException, BarException, then the implementing method is allowed to throw FooE, BarE, and any of their children. But if it turns out that my implementation only throws FooE, then I can declare throws FooE and skip the BarE in the implementation. If I also throw BarE, then I have to declare it. If the implementation also throws BazE and doesn't declare it, the compiler will complain about throwin an exception without declaring it, but if I declare it, then I'm violating the interface's contract, and the compiler will complain about that.
So which exceptions are declared/thrown is bound by a couple of things:
1) All methods must declare all the unchecked exceptions they throw (or superclass(es) that encompass those exceptions).
2) Any method that implements an interface cannot declare or throw any unchecked exceptions outside of what the interface declares.
2a) But it can declare/throw less
2b) But it still has to declare what it throws.
>
A user of your class who codes to the interfacestill has to handle the
exception that the interface throws. If they code toyour implementing
class, then they only have to handle whateverexceptions it throws--i.e.
a (possibly) empty subset of what the interfacedeclares.
This sounds like the class should declare that the
method could throw an exception... I'm not sure what
you mean by code to the interface vs code to the
implementing class..I've compiled a class which
implements an interface, the method in which includes
an Exception Specification. The class, however,
compiles without any mention of the Exception. Are
you saying that methods which call the method in the
class, must be prepared to catch the Exception of the
method which is implemented from the interface,
regardless of whether it is even announced in the
class?... It is implicitly passed on then..
interface Foo {
    void foo() throws FooE;
class FooImpl implements Foo {
    public void foo() { // I don't throw any exceptions, so I needn't declare anything
        // do nothing
// coding to the interface--the preferred way. All I know about f1 is that it's a Foo
Foo f1 = new FooImpl();
// coding to the implementation. I know that f2 is a FooImpl which implements Foo
FooImpl f2 = new FooImpl();
// f1 is a Foo, and therefore can throw FooE
try {
    f1.foo();
catch (FooE exc) {
    // handle
// f2 is a FooImpl, and therefore we know it throws no exceptions
f2.foo();Now that I think about it, I'm actually not 100% sure that my claims about having to catch only the implementation's exceptions (none, here) if you code to the implementation are accurate. I suggest you put the above code into some boilerplate and see if it compiles.