Quali sono tutti i diversi modi per creare un oggetto in Java?

L'altro giorno ho avuto una conversazione con un collega.

C'è l'ovvio usando un costruttore, ma quali sono gli altri modi lì?

Esistono quattro modi diversi per creare oggetti in Java:

A . Uso della newparola chiave
Questo è il modo più comune per creare un oggetto in Java. Quasi il 99% degli oggetti viene creato in questo modo.

 MyObject object = new MyObject();

B . Utilizzo Class.forName()
Se conosciamo il nome della classe e se ha un costruttore predefinito pubblico, possiamo creare un oggetto in questo modo.

MyObject object = (MyObject) Class.forName("subin.rnd.MyObject").newInstance();

C . Usando clone()
Il clone () può essere usato per creare una copia di un oggetto esistente.

MyObject anotherObject = new MyObject();
MyObject object = (MyObject) anotherObject.clone();

D . L'uso della object deserialization
deserializzazione di oggetti non è altro che la creazione di un oggetto dalla sua forma serializzata.

ObjectInputStream inStream = new ObjectInputStream(anInputStream );
MyObject object = (MyObject) inStream.readObject();

Puoi leggerli da qui .

Esistono vari modi:

• Attraverso Class.newInstance.
• Attraverso Constructor.newInstance.
• Attraverso la deserializzazione (usa il costruttore no-args della classe base non sierializzabile più derivata).
• Attraverso Object.clone( non chiama un costruttore ).
• Attraverso JNI (dovrebbe chiamare un costruttore).
• Attraverso qualsiasi altro metodo che chiama a newper te.
• Immagino che potresti descrivere il caricamento della classe come creazione di nuovi oggetti (come interned String).
• Un array letterale come parte dell'inizializzazione in una dichiarazione (nessun costruttore per gli array).
• La matrice in una ...chiamata del metodo "varargs" ( ) (nessun costruttore per le matrici).
• Concatenazione di stringhe costanti di tempo non compilabili (produce almeno quattro oggetti, in un'implementazione tipica).
• Causare un'eccezione da creare e generare dal runtime. Ad esempio throw null;o "".toCharArray()[0].
• Oh, e la boxe dei primitivi (a meno che non sia memorizzata nella cache), ovviamente.
• JDK8 dovrebbe avere lambda (essenzialmente classi interne anonime concise), che vengono convertite implicitamente in oggetti.
• Per completezza (e Paŭlo Ebermann), c'è anche una sintassi con la newparola chiave.

All'interno del linguaggio Java, l'unico modo per creare un oggetto è chiamare il suo costruttore, sia esplicitamente che implicitamente. Usando la riflessione si ottiene una chiamata al metodo del costruttore, la deserializzazione usa la riflessione per chiamare il costruttore, i metodi di fabbrica avvolgono la chiamata al costruttore per astrarre la costruzione effettiva e la clonazione è allo stesso modo una chiamata del costruttore chiusa.

Sì, puoi creare oggetti usando la riflessione. Ad esempio, String.class.newInstance()ti darà un nuovo oggetto String vuoto.

Esistono cinque modi diversi per creare un oggetto in Java,

1. Usando la newparola chiave → costruttore viene chiamato

Employee emp1 = new Employee();

2. Utilizzando il newInstance()metodo diClass → costruttore viene chiamato

Employee emp2 = (Employee) Class.forName("org.programming.mitra.exercises.Employee")
                                .newInstance();

Può anche essere scritto come

Employee emp2 = Employee.class.newInstance();

3. Utilizzando il newInstance()metodo diConstructor → costruttore viene chiamato

Constructor<Employee> constructor = Employee.class.getConstructor();
Employee emp3 = constructor.newInstance();

4. Utilizzo del clone()metodo → nessuna chiamata del costruttore

Employee emp4 = (Employee) emp3.clone();

5. Utilizzo della deserializzazione → nessuna chiamata del costruttore

ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.obj"));
Employee emp5 = (Employee) in.readObject();

Le prime tre newparole chiave dei metodi ed entrambe newInstance()includono una chiamata del costruttore, ma in seguito due metodi di clonazione e deserializzazione creano oggetti senza chiamare il costruttore.

Tutti i suddetti metodi hanno diversi bytecode associati, Leggi Diversi modi per creare oggetti in Java con esempi per esempi e descrizioni più dettagliate, ad es. Conversione bytecode di tutti questi metodi.

Tuttavia, si può sostenere che la creazione di un oggetto array o stringa è anche un modo per creare l'oggetto, ma queste cose sono più specifiche solo per alcune classi e gestite direttamente da JVM, mentre possiamo creare un oggetto di qualsiasi classe utilizzando questi 5 modi.

Clonazione e deserializzazione .

Inoltre puoi usare

 Object myObj = Class.forName("your.cClass").newInstance();

Questo dovrebbe essere notato se sei nuovo a Java, ogni oggetto ha ereditato da Object

il clone Object protetto nativo () genera CloneNotSupportedException;

Inoltre, è possibile deserializzare i dati in un oggetto. Questo non passa attraverso il costruttore di classe!

AGGIORNATO : Grazie Tom per averlo sottolineato nel tuo commento! E anche Michael ha sperimentato.

Passa attraverso il costruttore della superclasse non serializzabile più derivata.
E quando quella classe non ha un costruttore no-args, viene lanciata una InvalidClassException al momento della deserializzazione.

Si prega di consultare la risposta di Tom per un trattamento completo di tutti i casi ;-)
Esiste un altro modo per creare un oggetto senza utilizzare la "nuova" parola chiave in Java

Esiste un tipo di oggetto, che non può essere costruito dai normali meccanismi di creazione dell'istanza (chiamando costruttori): Array . Le matrici vengono create con

 A[] array = new A[len];

o

 A[] array = new A[] { value0, value1, value2 };

Come ha detto Sean in un commento, questo è sintatticamente simile a una chiamata del costruttore e internamente non è molto più che allocazione e inizializzazione zero (o inizializzazione con contenuto esplicito, nel secondo caso) un blocco di memoria, con qualche intestazione per indicare il digitare e la lunghezza.

Quando si passano argomenti a un metodo varargs, viene creato (e riempito) implicitamente anche un array.

Un quarto modo sarebbe

 A[] array = (A[]) Array.newInstance(A.class, len);

Naturalmente, anche qui la clonazione e la deserializzazione funzionano.

Esistono molti metodi nell'API standard che creano array, ma in realtà tutti usano uno (o più) di questi modi.

Altri modi se siamo esaustivi.

• In Oracle JVM è Unsafe.allocateInstance () che crea un'istanza senza chiamare un costruttore.
• Utilizzando manipolazione bytecode è possibile aggiungere il codice a anewarray, multianewarray, newarrayo new. Questi possono essere aggiunti usando librerie come ASM o BCEL. Una versione di bcel viene fornita con Oracle Java. Ancora una volta questo non chiama un costruttore, ma puoi chiamarlo come una chiamata separata.

Riflessione:

someClass.newInstance();

La riflessione farà anche il lavoro per te.

SomeClass anObj = SomeClass.class.newInstance();

è un altro modo per creare una nuova istanza di una classe. In questo caso, dovrai anche gestire le eccezioni che potrebbero essere generate.

• usando l' newoperatore (invocando così un costruttore)
• usando la riflessione clazz.newInstance()(che invoca nuovamente il costruttore). Oppure clazz.getConstructor(..).newInstance(..)(usando nuovamente un costruttore, ma puoi scegliere quale)

Riassumendo la risposta - un modo principale - invocando il costruttore della classe dell'oggetto.

Aggiornamento: un'altra risposta ha elencato due modi che non comportano l'uso di un costruttore: deseralizzazione e clonazione.

Esistono CINQUE modi diversi per creare oggetti in Java:

1. Usando la parola chiave `new`:

Questo è il modo più comune per creare un oggetto in Java. Quasi il 99% degli oggetti viene creato in questo modo.

MyObject object = new MyObject();//normal way

2. Utilizzando il metodo di fabbrica:

ClassName ObgRef=ClassName.FactoryMethod();

Esempio:

RunTime rt=Runtime.getRunTime();//Static Factory Method

3. Usando il concetto di clonazione:

Usando clone(), clone()può essere usato per creare una copia di un oggetto esistente.

MyObjectName anotherObject = new MyObjectName();
MyObjectName object = anotherObjectName.clone();//cloning Object

4. Utilizzando `Class.forName ()`:

Se conosciamo il nome della classe e se ha un costruttore predefinito pubblico, possiamo creare un oggetto in questo modo.

MyObjectName object = (MyObjectNmae) Class.forName("PackageName.ClassName").newInstance();

Esempio:

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

5. Utilizzo della deserializzazione degli oggetti:

La deserializzazione degli oggetti non è altro che la creazione di un oggetto dalla sua forma serializzata.

ObjectInputStreamName inStream = new ObjectInputStreamName(anInputStream );
MyObjectName object = (MyObjectNmae) inStream.readObject();

Puoi anche clonare oggetti esistenti (se implementa Cloneable).

Foo fooClone = fooOriginal.clone (); 

Metodo 1

Utilizzando una nuova parola chiave. Questo è il modo più comune per creare un oggetto in Java. Quasi il 99% degli oggetti viene creato in questo modo.

Employee object = new Employee();

Metodo 2

Utilizzando Class.forName (). Class.forName () ti dà l'oggetto di classe, che è utile per la riflessione. I metodi che ha questo oggetto sono definiti da Java, non dal programmatore che scrive la classe. Sono gli stessi per ogni classe. Chiamare newInstance () su che ti dà un'istanza di quella classe (es. CallingClass.forName ("ExampleClass"). NewInstance () equivale a chiamare new ExampleClass ()), su cui puoi chiamare i metodi che la classe definisce, accedere ai campi visibili ecc.

Employee object2 = (Employee) Class.forName(NewEmployee).newInstance();

Class.forName () utilizzerà sempre ClassLoader del chiamante, mentre ClassLoader.loadClass () può specificare un ClassLoader diverso. Credo che Class.forName inizializzi anche la classe caricata, mentre l'approccio ClassLoader.loadClass () non lo fa immediatamente (non è inizializzato fino a quando non viene usato per la prima volta).

Un altro deve leggere:

Java: Introduzione allo stato del thread con esempio Esempio di Enum Java semplice

Metodo 3

Usando clone (). Il clone () può essere utilizzato per creare una copia di un oggetto esistente.

Employee secondObject = new Employee();
Employee object3 = (Employee) secondObject.clone();

Metodo 4

Utilizzando il metodo newInstance ()

Object object4 = Employee.class.getClassLoader().loadClass(NewEmployee).newInstance();

Metodo 5

Utilizzo della deserializzazione degli oggetti. La deserializzazione di oggetti non è altro che la creazione di un oggetto dalla sua forma serializzata.

// Create Object5
// create a new file with an ObjectOutputStream
FileOutputStream out = new FileOutputStream("");
ObjectOutputStream oout = new ObjectOutputStream(out);

// write something in the file
oout.writeObject(object3);
oout.flush();

// create an ObjectInputStream for the file we created before
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("crunchify.txt"));
Employee object5 = (Employee) ois.readObject();

Dal punto di vista dell'utente API, un'altra alternativa ai costruttori sono i metodi factory statici (come BigInteger.valueOf ()), anche se per l'autore dell'API (e tecnicamente "per davvero") gli oggetti vengono comunque creati usando un costruttore.

Dipende esattamente cosa intendi per creare, ma alcuni altri sono:

• Metodo di clonazione
• deserializzazione
• Reflection (Class.newInstance ())
• Riflessione (oggetto costruttore)

c'è anche ClassLoader.loadClass (stringa) ma questo non è spesso usato.

e se vuoi essere un vero avvocato al riguardo, gli array sono tecnicamente oggetti a causa della proprietà .length di un array. l'inizializzazione di un array crea quindi un oggetto.

Possiamo creare un oggetto in 5 modi:

1. dal nuovo operatore
2. per riflessione (ad es. Class.forName () seguito da Class.newInstance ())
3. con il metodo di fabbrica
4. clonando
5. per riflessione api

Possiamo anche creare l'oggetto in questo modo: -

String s ="Hello";

Nessuno ne ha discusso.