Is it good practice to make the constructor throw an exception? [duplicate]

Throwing exceptions in a constructor is not bad practice. In fact, it is the only reasonable way for a constructor to indicate that there is a problem; e.g. that the parameters are invalid.

I also think that throwing checked exceptions can be OK¹, assuming that the checked exception is 1) declared, 2) specific to the problem you are reporting, and 3) it is reasonable to expect the caller to deal with a checked exception for this².

However explicitly declaring or throwing java.lang.Exception is almost always bad practice.

You should pick an exception class that matches the exceptional condition that has occurred. If you throw Exception it is difficult for the caller to separate this exception from any number of other possible declared and undeclared exceptions. This makes error recovery difficult, and if the caller chooses to propagate the Exception, the problem just spreads.

^{1 - Some people may disagree, but IMO there is no substantive difference between this case and the case of throwing exceptions in methods. The standard checked vs unchecked advice applies equally to both cases.
2 - For example, the existing FileInputStream constructors will throw FileNotFoundException if you try to open a file that does not exist. Assuming that it is reasonable for FileNotFoundException to be a checked exception3, then the constructor is the most appropriate place for that exception to be thrown. If we threw the FileNotFoundException the first time that (say) a read or write call was made, that is liable to make application logic more complicated.
3 - Given that this is one of the motivating examples for checked exceptions, if you don't accept this you are basically saying that all exceptions should be unchecked. That is not practical ... if you are going to use Java.}

Someone suggested using assert for checking arguments. The problem with this is that checking of assert assertions can be turned on and off via a JVM command-line setting. Using assertions to check internal invariants is OK, but using them to implement argument checking that is specified in your javadoc is not a good idea ... because it means your method will only strictly implement the specification when assertion checking is enabled.

The second problem with assert is that if an assertion fails, then AssertionError will be thrown, and received wisdom is that it is a bad idea to attempt to catch Error and any of its subtypes.

I've always considered throwing checked exceptions in the constructor to be bad practice, or at least something that should be avoided.

The reason for this is that you cannot do this :

private SomeObject foo = new SomeObject();

Instead you must do this :

private SomeObject foo;public MyObject() {    try {        foo = new SomeObject()    } Catch(PointlessCheckedException e) {       throw new RuntimeException("ahhg",e);    }}

At the point when I'm constructing SomeObject I know what it's parameters areso why should I be expected to wrap it in a try catch?Ahh you say but if I'm constructing an object from dynamic parameters I don't know if they're valid or not.Well, you could... validate the parameters before passing them to the constructor. That would be good practice.And if all you're concerned about is whether the parameters are valid then you can use IllegalArgumentException.

So instead of throwing checked exceptions just do

public SomeObject(final String param) {    if (param==null) throw new NullPointerException("please stop");    if (param.length()==0) throw new IllegalArgumentException("no really, please stop");}

Of course there are cases where it might just be reasonable to throw a checked exception

public SomeObject() {    if (todayIsWednesday) throw new YouKnowYouCannotDoThisOnAWednesday();}

But how often is that likely?

As mentioned in another answer here, in Guideline 7-3 of the Java Secure Coding Guidelines, throwing an exception in the constructor of a non-final class opens a potential attack vector:

Guideline 7-3 / OBJECT-3: Defend against partially initialized instances of non-final classes When a constructor in a non-final class throws an exception, attackers can attempt to gain access to partially initialized instances of that class. Ensure that a non-final class remains totally unusable until its constructor completes successfully.

From JDK 6 on, construction of a subclassable class can be prevented by throwing an exception before the Object constructor completes. To do this, perform the checks in an expression that is evaluated in a call to this() or super().

    // non-final java.lang.ClassLoader    public abstract class ClassLoader {        protected ClassLoader() {            this(securityManagerCheck());        }        private ClassLoader(Void ignored) {            // ... continue initialization ...        }        private static Void securityManagerCheck() {            SecurityManager security = System.getSecurityManager();            if (security != null) {                security.checkCreateClassLoader();            }            return null;        }    }

For compatibility with older releases, a potential solution involves the use of an initialized flag. Set the flag as the last operation in a constructor before returning successfully. All methods providing a gateway to sensitive operations must first consult the flag before proceeding:

    public abstract class ClassLoader {        private volatile boolean initialized;        protected ClassLoader() {            // permission needed to create ClassLoader            securityManagerCheck();            init();            // Last action of constructor.            this.initialized = true;        }        protected final Class defineClass(...) {            checkInitialized();            // regular logic follows            ...        }        private void checkInitialized() {            if (!initialized) {                throw new SecurityException(                    "NonFinal not initialized"                );            }        }    }

Furthermore, any security-sensitive uses of such classes should check the state of the initialization flag. In the case of ClassLoader construction, it should check that its parent class loader is initialized.

Partially initialized instances of a non-final class can be accessed via a finalizer attack. The attacker overrides the protected finalize method in a subclass and attempts to create a new instance of that subclass. This attempt fails (in the above example, the SecurityManager check in ClassLoader's constructor throws a security exception), but the attacker simply ignores any exception and waits for the virtual machine to perform finalization on the partially initialized object. When that occurs the malicious finalize method implementation is invoked, giving the attacker access to this, a reference to the object being finalized. Although the object is only partially initialized, the attacker can still invoke methods on it, thereby circumventing the SecurityManager check. While the initialized flag does not prevent access to the partially initialized object, it does prevent methods on that object from doing anything useful for the attacker.

Use of an initialized flag, while secure, can be cumbersome. Simply ensuring that all fields in a public non-final class contain a safe value (such as null) until object initialization completes successfully can represent a reasonable alternative in classes that are not security-sensitive.

A more robust, but also more verbose, approach is to use a "pointer to implementation" (or "pimpl"). The core of the class is moved into a non-public class with the interface class forwarding method calls. Any attempts to use the class before it is fully initialized will result in a NullPointerException. This approach is also good for dealing with clone and deserialization attacks.

    public abstract class ClassLoader {        private final ClassLoaderImpl impl;        protected ClassLoader() {            this.impl = new ClassLoaderImpl();        }        protected final Class defineClass(...) {            return impl.defineClass(...);        }    }    /* pp */ class ClassLoaderImpl {        /* pp */ ClassLoaderImpl() {            // permission needed to create ClassLoader            securityManagerCheck();            init();        }        /* pp */ Class defineClass(...) {            // regular logic follows            ...        }    }