I am instantiating a class like this.
myObj = (myObj) Class.forName("fully qualified class name here").newInstance();
My doubt here is if we have a constructor which takes arguments how can we instantiate it like above one.
Thanks,
Narendra
forName. Returns the Class object associated with the class or interface with the given string name, using the given class loader. Given the fully qualified name for a class or interface (in the same format returned by getName ) this method attempts to locate, load, and link the class or interface.
There are two ways to initialize a class object: Using a parenthesized expression list. The compiler calls the constructor of the class using this list as the constructor's argument list. Using a single initialization value and the = operator.
A constructor is typically used to initialize instance variables representing the main properties of the created object. If we don't supply a constructor explicitly, the compiler will create a default constructor which has no arguments and just allocates memory for the object.
Note that the constructor name must match the class name, and it cannot have a return type (like void ). Also note that the constructor is called when the object is created. All classes have constructors by default: if you do not create a class constructor yourself, Java creates one for you.
Use Class.getConstructor()
and call Constructor.newInstance()
on that. For example if this is your constructor on class Foo
:
public Foo(String bar, int baz) { }
You'd have to do something like this:
Constructor c = Class.forName("Foo").getConstructor(String.class, Integer.TYPE); Foo foo = (Foo) c.newInstance("example", 34);
You'll have to know what arguments need to be passed to the constructor. If that's not desirable you should consider having an empty constructor. Then have methods to set what you'd normally pass into the constructor.
One might ask if you have the right pattern here though. Do you really need to use reflection, perhaps there's a better approach? If you know you're going to be casting to your object already, why not just construct it normally? You might want to provide more context as to why you need to do this. There are valid reasons, however you haven't stated any.
newInstance()
always invokes default constructor.
if you want to invoke parametrized constructor,
Class[]
for getDeclaredConstructor
method of ClassObject[]
fornewInstance()
method of ConstructorHave a look at example code.
import java.lang.reflect.*; class NewInstanceDemo{ public NewInstanceDemo(){ System.out.println("Default constructor"); } public NewInstanceDemo(int a, long b){ System.out.println("Two parameter constructor : int,long => "+a+":"+b); } public NewInstanceDemo( int a, long b, String c){ System.out.println("Three parameter constructor : int,long,String => "+a+":"+b+":"+c); } public static void main(String args[]) throws Exception { NewInstanceDemo object = (NewInstanceDemo)Class.forName("NewInstanceDemo").newInstance(); Constructor constructor1 = NewInstanceDemo.class.getDeclaredConstructor( new Class[] {int.class, long.class}); NewInstanceDemo object1 = (NewInstanceDemo)constructor1.newInstance(new Object[]{1,2}); } }
output:
java NewInstanceDemo Default constructor Two parameter constructor : int,long => 1:2
Have a look at oracle documentation page for more details.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With