java - otra - Creando una instancia usando el nombre de la clase y llamando al constructor

metodos en java

Question

¿Hay una manera de crear una instancia de una clase particular dado el nombre de la clase (dinámico) y pasar parámetros a su constructor.

Algo como:

Object object = createInstance("mypackage.MyClass","MyAttributeValue");

Donde "MyAttributeValue" es un argumento para el constructor de MyClass .

Answer 1

Desea utilizar newInstance()

Answer 2

Otra respuesta útil. ¿Cómo uso getConstructor (params) .newInstance (args)?

return Class.forName(**complete classname**)
.getConstructor(**here pass parameters passed in constructor**)
.newInstance(**here pass arguments**);

En mi caso, el constructor de mi clase toma Webdriver como parámetro, por lo que se usa debajo del código:

return Class.forName("com.page.BillablePage")
.getConstructor(WebDriver.class)
.newInstance(this.driver);

Answer 3

Puede usar Class.forName() para obtener un objeto Class de la clase deseada.

Luego use getConstructor() para encontrar el objeto Constructor deseado.

Finalmente, llame a newInstance() en ese objeto para obtener su nueva instancia.

Class<?> c = Class.forName("mypackage.MyClass");
Constructor<?> cons = c.getConstructor(String.class);
Object object = cons.newInstance("MyAttributeValue");

Answer 4

Puedes usar reflexiones

return Class.forName(className).getConstructor(String.class).newInstance(arg);

Answer 5

Sí, algo como:

Class<?> clazz = Class.forName(className);
Constructor<?> ctor = clazz.getConstructor(String.class);
Object object = ctor.newInstance(new Object[] { ctorArgument });

Eso solo funcionará para un único parámetro de cadena, por supuesto, pero puede modificarlo con bastante facilidad.

Tenga en cuenta que el nombre de la clase debe ser completamente calificado, es decir, que incluya el espacio de nombres. Para las clases anidadas, necesita usar un dólar (ya que eso es lo que usa el compilador). Por ejemplo:

package foo;
public class Outer
{
public static class Nested {}
}

Para obtener el objeto Class para eso, necesitarías Class.forName("foo.Outer$Nested") .

Answer 6

Si alguien está buscando una manera de crear una instancia de una clase a pesar de la clase que sigue el Patrón Singleton, aquí hay una manera de hacerlo.

// 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();

Esto solo funciona para las clases que implementan un patrón singleton usando un constructor privado.

Answer 7

Si la clase solo tiene un constructor vacío (como Activity o Fragment, etc., clases de Android):

Class<?> myClass = Class.forName("com.example.MyClass");
Constructor<?> constructor = myClass.getConstructors()[0];

Answer 8

También puedes invocar métodos dentro del objeto creado.

Puede crear un objeto instantáneo invocando el primer constractor y luego invocar el primer método en el objeto creado.

 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);

Answer 9

cuando se usa (es decir, getConstructor(String.lang) el constructor debe declararse público. De lo contrario, se lanza una NoSuchMethodException .

si desea acceder a un constructor no público , debe utilizar en su lugar (es decir,) getDeclaredConstructor(String.lang) .

Answer 10

Una forma muy simple de crear un objeto en Java usando Class<?> Con argumentos del constructor pasando:

Caso 1: - Aquí, hay un pequeño código en esta clase Main :

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);
}
}

Y, aquí está la estructura de la clase 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: - Usted puede codificar de manera similar para el constructor con múltiples argumentos y copiar el constructor. Por ejemplo, pasar 3 argumentos como parámetro al constructor Base necesitará que el constructor se cree en la clase y un cambio de código en lo anterior como:

Constructor<?> ctr = myClass.getConstructor(String.class, String.class, String.class);
Object object = ctr.newInstance(new Object[] { "Arg1", "Arg2", "Arg3" });

Y aquí la clase Base debería verse de alguna manera como:

public class Base {
public Base(String a, String b, String c){
// This constructor need to be created in this case.
}
}

Nota: - No olvide manejar las diversas excepciones que deben manejarse en el código.