¿Hay alguna forma de instanciar una clase por nombre en Java?

Estaba mirando la pregunta: Crear una instancia de una clase a partir de su nombre de cadena, que describe cómo crear una instancia de una clase cuando tiene su nombre. ¿Hay alguna forma de hacerlo en Java? Tendré el nombre del paquete y el nombre de la clase y necesito poder crear un objeto con ese nombre en particular.

Dos caminos:

Método 1: solo para clases que tienen un constructor sin argumentos

Si su clase tiene un constructor sin argumentos, puede obtener un Classobjeto usando Class.forName()y usar el newInstance()método para crear una instancia (aunque tenga en cuenta que este método a menudo se considera malvado porque puede anular las excepciones marcadas de Java).

Por ejemplo:

Class<?> clazz = Class.forName("java.util.Date");
Object date = clazz.newInstance();

Método 2

Un enfoque alternativo más seguro que también funciona si la clase no tiene ningún constructor sin argumentos es consultar su objeto de clase para obtener su Constructorobjeto y llamar a un newInstance()método en este objeto:

Class<?> clazz = Class.forName("com.foo.MyClass");
Constructor<?> constructor = clazz.getConstructor(String.class, Integer.class);
Object instance = constructor.newInstance("stringparam", 42);

Ambos métodos se conocen como reflexión . Por lo general, tendrá que detectar las diversas excepciones que pueden ocurrir, incluidas cosas como:

• la JVM no puede encontrar o no puede cargar su clase
• la clase que intentas crear una instancia no tiene el tipo correcto de constructores
• el propio constructor lanzó una excepción
• el constructor que intentas invocar no es público
• Se ha instalado un administrador de seguridad que evita que se produzca la reflexión.

MyClass myInstance = (MyClass) Class.forName("MyClass").newInstance();

use Class.forName ("Nombre de cadena de clase"). newInstance ();

Class.forName("A").newInstance();

Esto hará que la clase denominada A se inicialice.

Para que sea más fácil obtener el nombre completo de una clase para crear una instancia usando Class.forName(...), se podría usar el Class.getName()método. Algo como:

class ObjectMaker {
    // Constructor, fields, initialization, etc...
    public Object makeObject(Class<?> clazz) {
        Object o = null;

        try {
            o = Class.forName(clazz.getName()).newInstance();
        } catch (ClassNotFoundException e) {
            // There may be other exceptions to throw here, 
            // but I'm writing this from memory.
            e.printStackTrace();
        }

        return o;
    }
}

Luego, puede convertir el objeto que obtiene a cualquier clase a la que pase makeObject(...):

Data d = (Data) objectMaker.makeObject(Data.class);

Utilice la reflexión de Java

Crear nuevos objetos No hay equivalente a la invocación de métodos para constructores, porque invocar un constructor es equivalente a crear un nuevo objeto (para ser más precisos, crear un nuevo objeto implica tanto la asignación de memoria como la construcción del objeto). Entonces, el equivalente más cercano al ejemplo anterior es decir:

import java.lang.reflect.*;

   public class constructor2 {
      public constructor2()
      {
      }

      public constructor2(int a, int b)
      {
         System.out.println(
           "a = " + a + " b = " + b);
      }

      public static void main(String args[])
      {
         try {
           Class cls = Class.forName("constructor2");
           Class partypes[] = new Class[2];
            partypes[0] = Integer.TYPE;
            partypes[1] = Integer.TYPE;
            Constructor ct 
              = cls.getConstructor(partypes);
            Object arglist[] = new Object[2];
            arglist[0] = new Integer(37);
            arglist[1] = new Integer(47);
            Object retobj = ct.newInstance(arglist);
         }
         catch (Throwable e) {
            System.err.println(e);
         }
      }
   }

que encuentra un constructor que maneja los tipos de parámetros especificados y lo invoca, para crear una nueva instancia del objeto. El valor de este enfoque es que es puramente dinámico, con búsqueda e invocación del constructor en tiempo de ejecución, en lugar de en tiempo de compilación.

Class.forName ("ClassName") resolverá su propósito.

Class class1 = Class.forName(ClassName);
Object object1 = class1.newInstance();

String str = (String)Class.forName("java.lang.String").newInstance();

Algo como esto debería funcionar...

String name = "Test2";//Name of the class
        Class myClass = Class.forName(name);
        Object o = myClass.newInstance();

El uso newInstance()directo está en desuso a partir de Java 8. Debe usar Class.getDeclaredConstructor(...).newInstance(...)con las excepciones correspondientes.