When creating an exception class should I implement all constructors of java.lang.Exception?

Question

When creating an exception class is it okay to only provide a "specific" constructor:

public CircularLinkException(final String msg, final String link)
{
    super(msg);
    link = inputName;
}

or should I implement the constructors of Exception:

public class CircularLinkException extends Exception
{
    public CircularLinkException() { /* ... */ }
    public CircularLinkException(final String msg) { /* ... */ }
    public CircularLinkException(final Throwable t) { /* ... */ }
    public CircularLinkException(final String msg, final Throwable t) { /* ... */ }
}

Answer 1

You should create all the Constructors you will use.

Don't add code when you imagine a use for something. Add it when you have a requirement for it.

http://c2.com/xp/YouArentGonnaNeedIt.html

Answer 2

It is not actually required to implement any particular constructor. One arbitrary can be implemented in order to construct the exception at all.

Usually two cases happen:

• Your code realizes that something went wrong after checking something. It wants to raise exception. For such case, a constructor that takes a string message is required. It is usually good to explain in the message that went wrong.
• Your code tries to do something and catches exception that cannot be thrown further as it is not declared. Then you still can explain that went wrong in the message, put some important context data there, but also it is vital to provide that catched exception for diagnostic. For such case, you need a constructor that takes String and Throwable.

I think, the version without parameters and the version that takes Throwable only are more for lazy people and you just enforce more order in your code by not implementing these.

If your specific exception benefit from some additional information that is always available, surely the constructor should have additional parameters, forcing to pass this information. In your case, a version with the two string parameters should be preserved but probably a version that also takes Throwable as a third parameter would be good. Many known exceptions (like IOException, for instance) went through the pain from "we will never need this kind of constructor" towards adding such constructor in the later versions.