C'è un modo per istanziare una classe in base al nome in Java?

Stavo cercando come la domanda: istanzia una classe dal suo nome di stringa che descrive come istanziare una classe quando ha il suo nome. C'è un modo per farlo in Java? Avrò il nome del pacchetto e il nome della classe e devo essere in grado di creare un oggetto con quel nome particolare.

Due strade:

Metodo 1: solo per classi che hanno un costruttore senza argomenti

Se la tua classe ha un costruttore senza argomenti, puoi ottenere un Classoggetto usando Class.forName()e utilizzare il newInstance()metodo per creare un'istanza (anche se fai attenzione che questo metodo è spesso considerato malvagio perché può sconfiggere le eccezioni controllate di Java).

Per esempio:

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

Metodo 2

Un approccio alternativo più sicuro che funziona anche se la classe non ha costruttori no-arg è interrogare il tuo oggetto di classe per ottenere il suo Constructoroggetto e chiamare un newInstance()metodo su questo oggetto:

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

Entrambi i metodi sono noti come riflessione . In genere dovrai rilevare le varie eccezioni che possono verificarsi, incluse cose come:

• la JVM non riesce a trovare o non riesce a caricare la tua classe
• la classe che stai cercando di istanziare non ha il giusto tipo di costruttori
• il costruttore stesso ha lanciato un'eccezione
• il costruttore che stai cercando di invocare non è pubblico
• è stato installato un gestore della sicurezza che impedisce la riflessione

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

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

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

Ciò causerà l'inizializzazione della classe A.

Per rendere più facile ottenere il nome completo di una classe per creare un'istanza utilizzando Class.forName(...), si potrebbe utilizzare il Class.getName()metodo. Qualcosa di simile a:

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

Quindi puoi eseguire il cast dell'oggetto che torni a qualsiasi classe a cui passi makeObject(...):

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

Usa la riflessione Java

Creazione di nuovi oggetti Non esiste alcun equivalente alla chiamata di metodo per i costruttori, perché invocare un costruttore equivale a creare un nuovo oggetto (per essere più precisi, la creazione di un nuovo oggetto implica sia l'allocazione della memoria che la costruzione dell'oggetto). Quindi l'equivalente più vicino all'esempio precedente è dire:

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

che trova un costruttore che gestisce i tipi di parametro specificati e lo invoca, per creare una nuova istanza dell'oggetto. Il valore di questo approccio è che è puramente dinamico, con la ricerca e il richiamo del costruttore al momento dell'esecuzione, piuttosto che al momento della compilazione.

Class.forName ("ClassName") risolverà il tuo scopo.

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

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

qualcosa del genere dovrebbe funzionare ...

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

L'utilizzo newInstance()diretto è deprecato a partire da Java 8. È necessario utilizzare Class.getDeclaredConstructor(...).newInstance(...)con le eccezioni corrispondenti.