Crear una instancia usando el nombre de la clase y llamar al constructor

¿Hay alguna manera de crear una instancia de una clase particular dado el nombre de la clase (dinámica) 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.

Sí, algo como:

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

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

Tenga en cuenta que el nombre de la clase debe ser totalmente calificado, es decir, incluir el espacio de nombres. Para las clases anidadas, debe 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 Classobjeto para eso, necesitarías Class.forName("foo.Outer$Nested").

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

Luego use getConstructor()para encontrar el Constructorobjeto deseado .

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

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

Puedes usar reflejos

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

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

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

cuando se usa (es decir), getConstructor(String.lang)el constructor debe ser declarado público. De lo contrario, NoSuchMethodExceptionse arroja un.

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

Desea utilizar java.lang.reflect.Constructor.newInstance (Object ...)

Manera muy simple de crear un objeto en Java usando Class<?>con argumento (s) de constructor pasando:

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

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 Baseestructura de clases:

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 constructor con argumento múltiple y constructor de copia. Por ejemplo, pasar 3 argumentos como parámetro al Baseconstructor necesitará que el constructor se cree en clase y un cambio de código arriba 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:

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.

Si alguien está buscando una manera de crear una instancia de una clase a pesar de que la clase 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 clases que implementan un patrón singleton usando un constructor privado.

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

Puede crear objetos instantáneamente invocando el primer limitador 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);

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