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
}
}