objeto - java reflection que es

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

Question

Estaba buscando la siguiente pregunta: crea una instancia de una clase desde su nombre de cadena que describe cómo crear una instancia de una clase cuando tiene su nombre. ¿Hay alguna manera de hacerlo en Java? Tendré el nombre del paquete y el nombre de clase y necesito poder crear un objeto que tenga ese nombre en particular.

Answer 1

Algo como esto debería funcionar...

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

Answer 2

Dos caminos:

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

Si su clase tiene un constructor no arg, puede obtener un objeto Class usando Class.forName() y usar el método newInstance() para crear una instancia (aunque tenga en cuenta que este método a menudo se considera malo porque puede vencer las excepciones comprobadas 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 no-arg es consultar su objeto de clase para obtener su objeto Constructor y llamar a un método newInstance() 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 reflection . Por lo general, deberá 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 no tiene el tipo correcto de constructores
• el propio constructor lanzó una excepción
• el constructor al que intentas invocar no es público
• Se ha instalado un administrador de seguridad que impide que se produzca la reflexión.

Answer 3

Para que sea más fácil obtener el nombre completo de una clase para crear una instancia utilizando Class.forName(...) , se podría usar el método Class.getName() . 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 puedes convertir el objeto que obtienes a cualquier clase que pases en makeObject(...) :

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

Answer 4

use Class.forName ("String name of class"). newInstance ();

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

Esto causará que la clase llamada A se inicialice.

Answer 5

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

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

Answer 6

Use la reflexión de java

Crear nuevos objetos No hay equivalente a la invocación de métodos para los constructores, porque invocar un constructor equivale a crear un nuevo objeto (para ser lo más preciso, crear un nuevo objeto implica la asignación de memoria y 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 de constructor e invocación en tiempo de ejecución, en lugar de tiempo de compilación.

Answer 7

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

Answer 8

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