Java newinstance () parameter versions and no-parameter versions

Newinstance () parameter version and no parameter version Blog Category:

• Core Java

There are two ways to create a new class sample from reflection:
Class.newinstance ()
Constructor.newinstance ()

The following two methods of invocation are compared to illustrate:
Class.newinstance () can only invoke the parameterless constructor, which is the default constructor;
Constructor.newinstance () can call any of the constructor constructors based on the parameters passed in.

Class.newinstance () throws all exceptions thrown by the called constructor.

Class.newinstance () requires that the constructor being called is visible, which must be of the public type;
Constructor.newinstance () in a specific case, you can call a private constructor.

Class A (The called example):
Java code

1. Public class A {
2. Private A () {
3. System.out.println ("A ' s constructor is called.");
4. }
6. private A (int a, int b) {
7. System.out.println ("A:" + A + "B:" + B);
8. }
9. }

Class B (caller):
Java code

2. Public class B {
4. public static void Main (string[] args) {
6. b b=new B ();
8. Out.println ("Call private constructor via Class.newinstance ():");
10. B.newinstancebyclassnewinstance ();
12. Out.println ("Call private constructor via Constructor.newinstance ():");
14. B.newinstancebyconstructornewinstance ();
16. }
18. /* Create a new class example via Class.newinstance () */
20. private void Newinstancebyclassnewinstance () {
22. try {/* Current package name reflect, must use full path * /
24. A a= (a) Class.forName ("reflect.   A "). newinstance ();
26. } catch (Exception e) {
28. Out.println ("failed" by calling the private constructor via Class.newinstance ());
30. }
32. }
36. /* Create a new class example via Constructor.newinstance () */
38. private void Newinstancebyconstructornewinstance () {
40. try {/* can use a relative path, which can be used without a package path in the same package * /
42. Class c=class.forname ("A");
44. /* Call the non-parameter, private constructor */
46. Constructor C0=c.getdeclaredconstructor ();
48. C0.setaccessible (true);
50. A a0= (a) c0.newinstance ();
52. /* Call the parameter, private constructor */
54. Constructor C1=c.getdeclaredconstructor (new class[]{Int.class,int.class});
56. C1.setaccessible (true);
58. A a1= (a) c1.newinstance (new object[]{5,6});
60. } catch (Exception e) {
62. E.printstacktrace ();
64. }
66. }
68. }

The input results are as follows:
The private constructor is called through Class.newinstance ():
Calling private constructor "failed" via Class.newinstance ()
The private constructor is called through Constructor.newinstance ():
A ' s constructor is called.
A:5 B:6

The description method newinstancebyclassnewinstance the call failed, and the method newinstancebyconstructornewinstance the call succeeded.
If the constructor of the called class is the default constructor, using Class.newinstance () is the better choice.
A code is OK, if the common people call the called class with a parameter constructor, a private constructor,
It is necessary to use Constractor.newinstance (), both of which are subject to availability.
However, Constractor.newinstance () is recommended in Java totorial.

Java newinstance () parameter versions and no-parameter versions