Why obtain a constructor object instead of directly creating an instance?

Question

Having:

Class<? extends MyInterface> clazz = ...;

should I (and why) write:

Constructor<? extends MyInterface> ctor = clazz.getConstructor();
MyInterface object = ctor.newInstance();

or:

MyInterface object = clazz.newInstance();

Does the choice depend on either the constructor I intend to use is empty or takes arguments?

score 1 · Answer 1 · answered Mar 27 '13 at 13:56

1

According to the Javadoc of newInstance():

The class is instantiated as if by a new expression with an empty argument list. The class is initialized if it has not already been initialized.

Appearantly, you can use newInstance() as a shortcut for

Constructor<? extends MyInterface> ctor = clazz.getConstructor();
MyInterface object = ctor.newInstance();

There's a subtle difference however: Class#newInstance() will wrap an Excption from the constructor inside a ExceptionInInitializerError, whereas the Constructor#newInstance() will wrap it inside an InvocationTargetException.

answered Mar 27 '13 at 13:56

mthmulders

9,483
4
37
54

so I guess, constructor usage is safer since it throws an `Exception` and not an `Error` .. – Queequeg Mar 27 '13 at 13:57
Exceptions indicate a problem a program _might want to catch_, while an Error indicates a problem that a program _should not try to catch_. Whether your application should catch an Exception in this dynamically invoked constructor depends on the situation... – mthmulders Mar 27 '13 at 14:08

score 1 · Accepted Answer · edited May 23 '17 at 12:11

Take a look at this similar question. This link also gives some more examples and a more detailed explanation.

To sum up the arguments (from the second link):

    Class.newInstance() can only invoke the zero-argument constructor, 
    while Constructor.newInstance() may invoke any constructor, regardless 
    of the number of parameters.

    Class.newInstance() throws any exception thrown by the constructor, 
    regardless of whether it is checked or unchecked. 

    Class.newInstance() requires that the constructor be visible;  
    Constructor.newInstance() may invoke private constructors under certain 
    circumstances.

Sorry for editing my post to add more quotes, but this explains it better than I could. The Javadoc for Class.newInstance() explains it like this:

Creates a new instance of the class represented by this Class object. The class is instantiated as if by a new expression with an empty argument list. The class is initialized if it has not already been initialized.

Note that this method propagates any exception thrown by the nullary constructor, including a checked exception. Use of this method effectively bypasses the compile-time exception checking that would otherwise be performed by the compiler. The Constructor.newInstance method avoids this problem by wrapping any exception thrown by the constructor in a (checked) InvocationTargetException.

I've actually read that thread before and feel that there could be some further discussion - "inline" examples are welcome! — Queequeg, Mar 27 '13 at 14:00
Please check the second paragraph: shouldn't it be `Constructor` ? — Queequeg, Mar 27 '13 at 14:06
What do you mean? the examples I gave were taken directly from the second link. — John Kane, Mar 27 '13 at 14:25
Take a look at the javadoc for Class.newInstance() they explain it a little more as well: http://docs.oracle.com/javase/7/docs/api/java/lang/Class.html#newInstance() — John Kane, Mar 27 '13 at 15:02

score 0 · Answer 3 · answered Mar 27 '13 at 13:55

0

According to the source code of java.lang.Class Class.newInstance() is the same as Constructor.newInstance()

In the implementation the default constructor (the one without any parameters) is invoked

answered Mar 27 '13 at 13:55

WeMakeSoftware

9,039
5
34
52

but with a lot happening in between – Queequeg Mar 27 '13 at 13:56
1

I prefer to use the API documentation as guidance, not any implementation. Too often I've seen an IBM JDK behave differently than the Sun/Oracle JDK... – mthmulders Mar 27 '13 at 13:57

score 0 · Answer 4 · answered Mar 27 '13 at 13:56

0

clazz.newInstance() actually attempts to get hold of the Constructor object, so it ends up being the same.

The first syntax allows instantiating classes using constructors with args.

answered Mar 27 '13 at 13:56

Bruno Grieder

28,128
8
69
101

score 0 · Answer 5 · answered Mar 27 '13 at 13:58

The answer is obvious from a thorough reading of the javadoc for java.lang.Class.

The clazz.newInstance() approach only works with a no-args constructor.
The clazz.getConstructor(), etc approach also works with constructors with arguments ... provided that you supply the types and then the values of the constructor arguments.

If your use-case only requires you to use the no-args constructor, then clazz.newInstance() is the simpler approach.

simpler, but throwing an Error :( – Queequeg Mar 27 '13 at 14:05 — Queequeg, Mar 27 '13 at 14:05

Why obtain a constructor object instead of directly creating an instance?

5 Answers5