Existe uma forma de criar uma instância de uma determinada classe dada o nome da classe (dinâmica) e passar parâmetros ao seu construtor.
Algo do género:
Object object = createInstance("mypackage.MyClass","MyAttributeValue");
Onde "MyAttributeValue"
é um argumento para o construtor de MyClass
.
Sim, algo do género:
Class<?> clazz = Class.forName(className);
Constructor<?> ctor = clazz.getConstructor(String.class);
Object object = ctor.newInstance(new Object[] { ctorArgument });
Isso só funcionará para um único parâmetro de corda, claro, mas pode modificá-lo muito facilmente.
Note-se que o nome da classe tem de ser um nome totalmente qualificado, ou seja, incluindo o namespace. Para as classes aninhadas, é necessário usar um dólar (como aquele's que o compilador usa). Por exemplo:
package foo;
public class Outer
{
public static class Nested {}
}
Para obter o objecto Class
para isso, você'necessitaria Class.forName("foo.Outer$Nested")
.
Pode utilizar Class.forName()
para obter um objecto Class
da classe desejada.
Depois utilizar getConstructor()` para encontrar o objecto desejado Constructor
.
Finalmente, ligue newInstance()
sobre esse objecto para obter a sua nova instância.
Class<?> c = Class.forName("mypackage.MyClass");
Constructor<?> cons = c.getConstructor(String.class);
Object object = cons.newInstance("MyAttributeValue");
ao utilizar (isto é) getConstructor(String.lang)
o construtor tem de ser declarado público.
Caso contrário, um `NoSuchMethodException' é lançado.
Se você quiser acessar um non-public constructor você tem que utilizar (i.e.) getDeclaredConstructor(String.lang)
.
Você quer estar usando [java.lang.reflect.Constructor.newInstance(Object...)][1]
Muito simples para criar um objeto em Java utilizando Class<?>
com o(s) argumento(s) do construtor passando:
**Paso 1:-*** Aqui, há um pequeno código nesta classe "Principal":
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class Main {
public static void main(String args[]) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
// Get class name as string.
String myClassName = Base.class.getName();
// Create class of type Base.
Class<?> myClass = Class.forName(myClassName);
// Create constructor call with argument types.
Constructor<?> ctr = myClass.getConstructor(String.class);
// Finally create object of type Base and pass data to constructor.
String arg1 = "My User Data";
Object object = ctr.newInstance(new Object[] { arg1 });
// Type-cast and access the data from class Base.
Base base = (Base)object;
System.out.println(base.data);
}
}
E, aqui está a estrutura de classes Base
:
public class Base {
public String data = null;
public Base()
{
data = "default";
System.out.println("Base()");
}
public Base(String arg1) {
data = arg1;
System.out.println("Base("+arg1+")");
}
}
**Caso 2:-*** Você, pode codificar de forma similar para construtor com múltiplos argumentos e construtor de cópias.
Por exemplo, passando 3 argumentos como parâmetro para o construtor Base
precisará que o construtor seja criado na classe e uma mudança no código acima como:
Constructor<?> ctr = myClass.getConstructor(String.class, String.class, String.class);
Object object = ctr.newInstance(new Object[] { "Arg1", "Arg2", "Arg3" });
E aqui a classe Base deve, de alguma forma, ser parecida:
public class Base {
public Base(String a, String b, String c){
// This constructor need to be created in this case.
}
}
**Note:-** Don'não se esqueça de tratar das várias excepções que precisam de ser tratadas no código.*
Você também pode invocar métodos dentro do objeto criado.
O usuário pode criar o objeto instantaneamente ao invocar a primeira restrição e depois invocar o primeiro método no objeto criado.
Class<?> c = Class.forName("mypackage.MyClass");
Constructor<?> ctor = c.getConstructors()[0];
Object object=ctor.newInstance(new Object[]{"ContstractorArgs"});
c.getDeclaredMethods()[0].invoke(object,Object... MethodArgs);
Outra resposta útil. Como eu uso getConstructor(params).newInstance(args)?](https://stackoverflow.com/a/9335669/3181500)
return Class.forName(**complete classname**)
.getConstructor(**here pass parameters passed in constructor**)
.newInstance(**here pass arguments**);
No meu caso, o construtor da minha classe's toma Webdriver como parâmetro, assim utilizado abaixo do código:
return Class.forName("com.page.BillablePage")
.getConstructor(WebDriver.class)
.newInstance(this.driver);
Se alguém está procurando uma maneira de criar uma instância de uma classe apesar da classe seguir o Padrão de Singleton, aqui está uma maneira de fazê-lo.
// Get Class instance
Class<?> clazz = Class.forName("myPackage.MyClass");
// Get the private constructor.
Constructor<?> cons = clazz.getDeclaredConstructor();
// Since it is private, make it accessible.
cons.setAccessible(true);
// Create new object.
Object obj = cons.newInstance();
Isto só funciona para classes que implementam padrão singleton utilizando um construtor privado.