Question: I'm defining a new interface API... admittedly not something I do all that often. I'd like to define the interface methods to throw an Exception to allow some flexibility for the implementers. They can then choose to throw an Exception, throw a more specific subclass of Exception, or throw nothing at all. I've read a couple of times that while its good to allow implementing classes this flexibility, it's also bad to define the interface method with "throws Exception". Instead, it's recommended to subclass Exception (e.g. MyException) and throw the subclass. The explanations for this practice were lacking in detail, so can someone elaborate on this best practice please? Thanks.

Answer: 
I prefer to throw Java standard subclass of `RuntimeException`. This gives the flexibility of allowing the Exception to propagate or be caught without having references to your API.

There are many subclasses to choose from <http://docs.oracle.com/javase/7/docs/api/java/lang/RuntimeException.html>

Often I use `IllegalStateException` or `IllegalArgumentException`
The reason for saying that an interface method declaring to throw the base class `Exception` is bad practice is because it would in fact make throwing an instance of that very base class a legal implementation of the interface, which is what you clearly want to avoid.

This is why you would only use specialized/custom exception types in your signatures.

I wouldn't go as far as saying that an interface should not declare a throwing of any Exception in advance, as someone said in his answer previously, because the interface is in fact not free floating. 

You, as the one declaring the interface, invoke or use the methods in a certain way, and you make assertions on how the methods will be used by your side of the code. 

It is in fact a contract that you create. **And exceptions are a part of that contract.** In fact the one using the interface (not the one implementing it) will be done with his work way before an implementation may exist.