tipos - Crear una nueva clase a partir de una variable en Java

que es string en java

Question

¿Hay alguna manera de crear una nueva clase a partir de una variable String en Java?

String className = "Class1";
//pseudocode follows
Object xyz = new className(param1, param2);

Además, si es posible ¿el objeto resultante debe ser de tipo Objeto?

Puede haber una manera mejor, pero quiero poder recuperar valores de un archivo XML y luego crear las clases nombradas después de esas cadenas. Cada una de las clases implementa todas la misma interfaz y se derivan de la misma clase principal, por lo que sería capaz de llamar a un método en particular en esa clase.

Answer 1

Un programa de ejemplo para obtener instancia de una class usando String Object.

public class GetStudentObjectFromString
{
public static void main (String[] args) throws java.lang.Exception
{
String className = "Student"; //Passed the Class Name in String Object.
//A Object of Student will made by Invoking its Default Constructor.
Object o = Class.forName(className).newInstance();
if(o instanceof Student) // Verify Your Instance that Is it Student Type or not?
System.out.println("Hurrey You Got The Instance of " + className);
}
}
class Student{
public Student(){
System.out.println("Constructor Invoked");
}
}

Salida: -

 Constructor Invoked
Hurrey You Got The Instance of Student

Answer 2

Esto debería funcionar:

import java.lang.reflect.*;
FirstArgType arg1;
SecondArgType arg2;
Class cl = Class.forName("TheClassName");
Constructor con = cl.getConstructor(FirstArgType.class, SecondArgType.class);
Object obj = con.newInstance(arg1, arg2);

Desde allí puedes convertir a un tipo conocido.

Answer 3

Esto es lo que quieres hacer:

String className = "Class1";
Object xyz = Class.forName(className).newInstance();

Tenga en cuenta que el método newInstance no permite el uso de un constructor parametrizado. (Consulte la documentación de Class.newInstance )

Si necesita usar un constructor parametrizado, esto es lo que debe hacer:

import java.lang.reflect.*;
Param1Type param1;
Param2Type param2;
String className = "Class1";
Class cl = Class.forName(className);
Constructor con = cl.getConstructor(Param1Type.class, Param2Type.class);
Object xyz = con.newInstance(param1, param2);

Consulte la documentación de Constructor.newInstance

Answer 4

Esto funcionó un poco más limpio para mí en JDK7, mientras que las respuestas anteriores hicieron las cosas un poco más difíciles de lo que debían ser desde la perspectiva de un novato: (supone que has declarado ''className'' como una variable String pasada como parámetro de método o anteriormente en el método que usa este código):

Class<?> panel = Class.forName( className );
JPanel newScreen = (JPanel) panel.newInstance();

A partir de este punto, puede usar propiedades / métodos de su clase nombrada dinámicamente exactamente como cabría esperar para poder usarlos:

JFrame frame = new JFrame(); // <<< Just so no-one gets lost here
frame.getContentPane().removeAll();
frame.getContentPane().add( newScreen );
frame.validate();
frame.repaint();

Los ejemplos en otras respuestas anteriores generaron errores cuando intenté agregar () el nuevo objeto de tipo ''Objeto'' al marco. La técnica que se muestra aquí me dio un objeto útil con solo esas 2 líneas de código de arriba.

No estoy exactamente seguro de por qué fue eso, soy un novato de Java.

Answer 5

Otro:

import java.lang.reflect.Constructor;
public class Test {
public Test(String name) {
this.name = name;
}
public String getName() {
return name;
}
public String toString() {
return this.name;
}
private String name;
public static void main(String[] args) throws Exception {
String className = "Test";
Class clazz = Class.forName(className);
Constructor tc = clazz.getConstructor(String.class);
Object t = tc.newInstance("John");
System.out.println(t);
}
}

Answer 6

Sí, puede cargar una clase en su classpath dado el nombre String usando reflection, usando Class.forName (name), agarrando el constructor e invocando. Te haré un ejemplo.

Considera que tengo una clase:

com.crossedstreams.thingy.Foo

Que tiene un constructor con firma:

Foo(String a, String b);

Me gustaría crear una instancia de la clase basada en estos dos hechos de la siguiente manera:

// Load the Class. Must use fully qualified name here!
Class clazz = Class.forName("com.crossedstreams.thingy.Foo");
// I need an array as follows to describe the signature
Class[] parameters = new Class[] {String.class, String.class};
// Now I can get a reference to the right constructor
Constructor constructor = clazz.getConstructor(parameters);
// And I can use that Constructor to instantiate the class
Object o = constructor.newInstance(new Object[] {"one", "two"});
// To prove it''s really there...
System.out.println(o);

Salida:

com.crossedstreams.thingy.Foo@20cf2c80

Hay muchos recursos que detallan más sobre esto, y debe tener en cuenta que está introduciendo una dependencia que el compilador no puede verificar por usted; si escribe mal el nombre de la clase o algo así, fallará en tiempo de ejecución. . Además, hay bastantes tipos diferentes de Exception que pueden arrojarse durante este proceso. Sin embargo, es una técnica muy poderosa.