Quelles sont les différentes manières de créer un objet en Java?

J'ai eu une conversation avec un collègue l'autre jour à ce sujet.

Il y a l'évidence d'utiliser un constructeur, mais quelles sont les autres façons?

Il existe quatre façons différentes de créer des objets en java:

A . Utilisation du newmot-clé
C'est la manière la plus courante de créer un objet en java. Près de 99% des objets sont créés de cette manière.

 MyObject object = new MyObject();

B . En utilisant Class.forName()
Si nous connaissons le nom de la classe et si elle a un constructeur par défaut public, nous pouvons créer un objet de cette manière.

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

C . clone()
L' utilisation de The clone () peut être utilisée pour créer une copie d'un objet existant.

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

D . Utiliser la object deserialization
désérialisation d'objet n'est rien d'autre que créer un objet à partir de sa forme sérialisée.

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

Vous pouvez les lire ici .

Il existe différentes manières:

• À travers Class.newInstance.
• À travers Constructor.newInstance.
• Par la désérialisation (utilise le constructeur no-args de la classe de base non sérialisable la plus dérivée).
• Through Object.clone( n'appelle pas de constructeur ).
• Via JNI (devrait appeler un constructeur).
• Par toute autre méthode qui appelle un newpour vous.
• Je suppose que vous pourriez décrire le chargement de classe comme la création de nouveaux objets (tels que des internés String).
• Un tableau littéral faisant partie de l'initialisation dans une déclaration (pas de constructeur pour les tableaux).
• Le tableau dans un ...appel de méthode "varargs" ( ) (pas de constructeur pour les tableaux).
• Concaténation de chaînes à constante de temps non compilée (produit au moins quatre objets, sur une implémentation typique).
• Provoque la création et la levée d'une exception par le runtime. Par exemple throw null;ou "".toCharArray()[0].
• Oh, et la boxe des primitifs (sauf en cas de cache), bien sûr.
• JDK8 doit avoir des lambdas (classes internes anonymes essentiellement concises), qui sont implicitement converties en objets.
• Pour être complet (et Paŭlo Ebermann), il existe également une syntaxe avec le newmot - clé.

Dans le langage Java, la seule façon de créer un objet est d'appeler son constructeur, que ce soit explicitement ou implicitement. L'utilisation de la réflexion entraîne un appel à la méthode du constructeur, la désérialisation utilise la réflexion pour appeler le constructeur, les méthodes de fabrique encapsulent l'appel au constructeur pour faire abstraction de la construction réelle et le clonage est de la même manière un appel de constructeur encapsulé.

Oui, vous pouvez créer des objets en utilisant la réflexion. Par exemple, String.class.newInstance()vous donnera un nouvel objet String vide.

Il existe cinq façons différentes de créer un objet en Java,

1. En utilisant le newmot-clé → le constructeur est appelé

Employee emp1 = new Employee();

2. En utilisant la newInstance()méthode deClass → le constructeur est appelé

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

Il peut également être écrit comme

Employee emp2 = Employee.class.newInstance();

3. En utilisant la newInstance()méthode deConstructor → le constructeur est appelé

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

4. Utilisation de la clone()méthode → aucun appel de constructeur

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

5. Utilisation de la désérialisation → pas d'appel au constructeur

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

Les trois premiers newmots-clés de méthodes et les deux newInstance()incluent un appel au constructeur, mais plus tard, deux méthodes de clonage et de désérialisation créent des objets sans appeler le constructeur.

Toutes les méthodes ci-dessus ont différents bytecode qui leur sont associés, Lire Différentes façons de créer des objets en Java avec exemple pour des exemples et une description plus détaillée, par exemple la conversion de bytecode de toutes ces méthodes.

Cependant, on peut affirmer que la création d'un objet tableau ou chaîne est également un moyen de créer l'objet, mais ces choses sont plus spécifiques à certaines classes uniquement et gérées directement par JVM, alors que nous pouvons créer un objet de n'importe quelle classe en utilisant ces 5 méthodes.

Clonage et désérialisation .

Vous pouvez également utiliser

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

Cela doit être remarqué si vous êtes nouveau sur Java, chaque objet a hérité d'Object

Protégé native Object clone () lance CloneNotSupportedException;

En outre, vous pouvez désérialiser les données dans un objet. Cela ne passe pas par la classe Constructor!

MISE À JOUR : Merci Tom d'avoir souligné cela dans votre commentaire! Et Michael a également expérimenté.

Il passe par le constructeur de la superclasse non sérialisable la plus dérivée.
Et lorsque cette classe n'a pas de constructeur no-args, une exception InvalidClassException est lancée lors de la désérialisation.

S'il vous plaît voir la réponse de Tom pour un traitement complet de tous les cas ;-)
existe-t-il un autre moyen de créer un objet sans utiliser le mot clé "new" en java

Il existe un type d'objet, qui ne peut pas être construit par des mécanismes de création d'instances normaux (appelant des constructeurs): tableaux . Les tableaux sont créés avec

 A[] array = new A[len];

ou

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

Comme Sean l'a dit dans un commentaire, c'est syntaxiquement similaire à un appel de constructeur et en interne ce n'est pas beaucoup plus que l'allocation et l'initialisation à zéro (ou l'initialisation avec un contenu explicite, dans le second cas) un bloc de mémoire, avec un en-tête pour indiquer le le type et la longueur.

Lorsque vous passez des arguments à une méthode varargs, un tableau est également créé (et rempli) implicitement.

Une quatrième façon serait

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

Bien sûr, le clonage et la désérialisation fonctionnent ici aussi.

Il existe de nombreuses méthodes dans l'API standard qui créent des tableaux, mais elles utilisent toutes en fait une (ou plusieurs) de ces méthodes.

D'autres moyens si nous sommes exhaustifs.

• Sur Oracle JVM, Unsafe.allocateInstance () crée une instance sans appeler de constructeur.
• En utilisant la manipulation de code octet , vous pouvez ajouter du code à anewarray, multianewarray, newarrayou new. Ceux-ci peuvent être ajoutés à l'aide de bibliothèques telles que ASM ou BCEL. Une version de bcel est livrée avec Java d'Oracle. Encore une fois, cela n'appelle pas de constructeur, mais vous pouvez appeler un constructeur en tant qu'appel séparé.

Réflexion:

someClass.newInstance();

La réflexion fera également le travail pour vous.

SomeClass anObj = SomeClass.class.newInstance();

est une autre façon de créer une nouvelle instance d'une classe. Dans ce cas, vous devrez également gérer les exceptions susceptibles d'être levées.

• en utilisant l' newopérateur (invoquant ainsi un constructeur)
• en utilisant la réflexion clazz.newInstance()(qui appelle à nouveau le constructeur). Ou par clazz.getConstructor(..).newInstance(..)(à nouveau en utilisant un constructeur, mais vous pouvez donc choisir lequel)

Pour résumer la réponse - une manière principale - en invoquant le constructeur de la classe de l'objet.

Mise à jour: Une autre réponse a répertorié deux méthodes qui n'impliquent pas l'utilisation d'un constructeur: la déséralisation et le clonage.

Il existe CINQ façons différentes de créer des objets en Java:

1. Utilisation du mot-clé «new»:

C'est la manière la plus courante de créer un objet en Java. Près de 99% des objets sont créés de cette manière.

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

2. En utilisant la méthode d'usine:

ClassName ObgRef=ClassName.FactoryMethod();

Exemple:

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

3. En utilisant le concept de clonage:

En utilisant clone(), le clone()peut être utilisé pour créer une copie d'un objet existant.

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

4. En utilisant `Class.forName ()`:

Si nous connaissons le nom de la classe et si elle a un constructeur par défaut public, nous pouvons créer un objet de cette manière.

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

Exemple:

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

5. Utilisation de la désérialisation d'objet:

La désérialisation d'objet n'est rien d'autre que la création d'un objet à partir de sa forme sérialisée.

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

Vous pouvez également cloner un objet existant (s'il implémente Cloneable).

Foo fooClone = fooOriginal.clone (); 

Méthode 1

Utilisation d'un nouveau mot-clé. C'est la manière la plus courante de créer un objet en java. Près de 99% des objets sont créés de cette manière.

Employee object = new Employee();

Méthode 2

Utilisation de Class.forName (). Class.forName () vous donne l'objet de classe, ce qui est utile pour la réflexion. Les méthodes de cet objet sont définies par Java, pas par le programmeur qui écrit la classe. Ils sont les mêmes pour chaque classe. L'appel de newInstance () sur qui vous donne une instance de cette classe (c'est-à-dire callClass.forName ("ExampleClass"). NewInstance () équivaut à appeler new ExampleClass ()), sur lequel vous pouvez appeler les méthodes que la classe définit, accéder aux champs visibles etc.

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

Class.forName () utilisera toujours le ClassLoader de l'appelant, tandis que ClassLoader.loadClass () peut spécifier un ClassLoader différent. Je crois que Class.forName initialise également la classe chargée, alors que l'approche ClassLoader.loadClass () ne le fait pas tout de suite (elle n'est initialisée que lorsqu'elle est utilisée pour la première fois).

Un autre doit lire:

Java: Introduction à l'état des threads avec un exemple Exemple simple d'énumération Java

Méthode 3

Utilisation de clone (). Le clone () peut être utilisé pour créer une copie d'un objet existant.

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

Méthode 4

Utilisation de la méthode newInstance ()

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

Méthode 5

Utilisation de la désérialisation d'objets. La désérialisation d'objet n'est rien d'autre que la création d'un objet à partir de sa forme sérialisée.

// 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();

Du point de vue de l'utilisateur de l'API, une autre alternative aux constructeurs sont les méthodes de fabrique statiques (comme BigInteger.valueOf ()), bien que pour l'auteur de l'API (et techniquement "pour de vrai") les objets soient toujours créés à l'aide d'un constructeur.

Cela dépend exactement de ce que vous entendez par créer, mais d'autres sont:

• Méthode de clonage
• Désérialisation
• Réflexion (Class.newInstance ())
• Reflection (objet Constructor)

il y a aussi ClassLoader.loadClass (string) mais ce n'est pas souvent utilisé.

et si vous voulez être un avocat total à ce sujet, les tableaux sont techniquement des objets en raison de la propriété .length d'un tableau. donc l'initialisation d'un tableau crée un objet.

Nous pouvons créer un objet de 5 manières:

1. par nouvel opérateur
2. par réflexion (par exemple Class.forName () suivi de Class.newInstance ())
3. par méthode d'usine
4. par clonage
5. par reflet api

Nous pouvons également créer l'objet de cette manière: -

String s ="Hello";

Personne n'en a discuté.