Java interface throws an exception but interface implementation does not throw an exception?

A general rule of implementing and extending is you can make your new class or interface "less restrictive" but not "more restrictive". If you think of the requirement to handle an exception as a restriction, an implementation that doesn't declare the exception is less restrictive. Anybody who codes to the interface will not have trouble with your class.

— Stan James

---

As part of the discussion at http://www.coderanch.com/t/399874/java/java/Methods-throwing-Exception-Interface

If a Java method overrides another in a parent class, or implements a method defined in an interface, it may not throw additional checked exceptions, but it may throw fewer.

public class A {
    public void thrower() throws SQLException {...}
}

public class B extends A {
    @Override
    public void thrower() throws SQLException, RuntimeException, NamingException {...}
}

SQLException is fine; it's declared in the overridden method. It could even be replaced by a subclass like SerialException.

RuntimeException is fine; those can be used anywhere.

NamingException is illegal. It isn't a RuntimeException, and isn't in A's list, even as a subtype.

Great answer by @Chetter Hummin.

One way to look at this, and I find it easy to remember, is interface's implementations can be more specific but not more general.

For example in interface void test() throws Exception means "test may throw exception"

then implementation can be void test() means "test will not throw exception" (more specific)

or implementation can be void test() throws NullpointerException (more specific)

interface x {
    void testException() throws Exception;
}

public class ExceptionTest implements x {
    @Override
    public void testException() {   //this is fine
    }

    ////// or

    @Override
    public void testException() throws NullPointerException {  // this is fine
    }
}