Le objet est un élément de base d'un Oops langue. Dans Java , nous ne pouvons exécuter aucun programme sans créer un objet . Il existe différentes manières de créé un objet en Java dont nous discuterons dans cette section, et apprendrons également comment créer un objet en Java.
Java propose cinq façons de créer un objet.
- En utilisant nouveau Mot-clé
- En utilisant cloner() méthode
- En utilisant nouvelleInstance() méthode du Classe classe
- En utilisant nouvelleInstance() méthode du Constructeur classe
- En utilisant Désérialisation
Utilisation d'un nouveau mot-clé
En utilisant le nouveau Le mot-clé est le moyen le plus populaire de créer un objet ou une instance de la classe. Lorsque nous créons une instance de la classe à l'aide du mot-clé new, il alloue de la mémoire (tas) pour la nouvelle instance créée. objet et renvoie également le référence de cet objet à cette mémoire. Le mot-clé new est également utilisé pour créer un tableau. La syntaxe pour créer un objet est la suivante :
ClassName object = new ClassName();
Créons un programme qui utilise le nouveau mot-clé pour créer un objet.
CreateObjectExample1.java
public class CreateObjectExample1 { void show() { System.out.println('Welcome to javaTpoint'); } public static void main(String[] args) { //creating an object using new keyword CreateObjectExample1 obj = new CreateObjectExample1(); //invoking method using the object obj.show(); } } Sortir:
Welcome to javaTpoint
En utilisant le mot-clé new, on peut également invoquer le constructeur (par défaut ou paramétré) de la classe.
CreateObjectExample2.java
pages du serveur Java
public class CreateObjectExample2 { //constructor of the class CreateObjectExample2() { System.out.println('Welcome to javaTpoint'); } public static void main(String[] args) { //creating an object using new keyword CreateObjectExample2 obj = new CreateObjectExample2(); } } Sortir:
Welcome to javaTpoint
Utilisation de la méthode clone()
Le cloner() la méthode est la méthode de Objet classe. Il crée une copie d'un objet et renvoie la même copie. Le JVM crée un nouvel objet lorsque la méthode clone() est invoquée. Il copie tout le contenu de l'objet précédemment créé dans un nouvel objet. Notez qu’il n’appelle aucun constructeur. Nous devons mettre en œuvre le Clonable interface en utilisant la méthode clone(). La méthode jette CloneNotSupportedException exception si la classe de l'objet ne prend pas en charge l'interface Cloneable. Les sous-classes qui remplacent la méthode clone() peuvent lever une exception si une instance ne peut pas être clonée.
Remarque : La méthode crée une copie de l'objet et non un nouvel objet.
Syntaxe:
protected Object clone() throws CloneNotSupportedException
Nous utilisons l'instruction suivante pour créer un nouvel objet.
ClassName newobject = (ClassName) oldobject.clone();
CreateObjectExample3.java
string.contient java
public class CreateObjectExample3 implements Cloneable { @Override protected Object clone() throws CloneNotSupportedException { //invokes the clone() method of the super class return super.clone(); } String str = 'New Object Created'; public static void main(String[] args) { //creating an object of the class CreateObjectExample3 obj1 = new CreateObjectExample3(); //try catch block to catch the exception thrown by the method try { //creating a new object of the obj1 suing the clone() method CreateObjectExample3 obj2 = (CreateObjectExample3) obj1.clone(); System.out.println(obj2.str); } catch (CloneNotSupportedException e) { e.printStackTrace(); } } } Sortir:
New Object Created
Utilisation de la méthode newInstance() de la classe Class
Le nouvelleInstance() La méthode de la classe Class est également utilisée pour créer un objet. Il appelle le constructeur par défaut pour créer l'objet. Il renvoie une instance nouvellement créée de la classe représentée par l'objet. Il utilise en interne la méthode newInstance() de la classe Constructor.
Syntaxe:
public T newInstance() throws InstantiationException, IllegalAccessException
Il jette le Exception d'accès illégal, InstantiationException, ExceptionInInitializerError des exceptions.
Nous pouvons créer un objet des manières suivantes :
ClassName object = ClassName.class.newInstance();
Ou
ClassName object = (ClassName) Class.forName('fully qualified name of the class').newInstance();
Dans la déclaration ci-dessus, pourNom() est une méthode statique de la classe Class. Il analyse un paramètre nom du cours de type Chaîne. Il renvoie l'objet de la classe avec le nom complet. Il charge la classe mais ne crée aucun objet. Ça jette ClassNotFoundException si la classe ne peut pas être chargée et Erreur de liaison si la liaison échoue.
Pour créer l'objet, nous utilisons le nouvelleInstance() méthode de la classe Class. Cela ne fonctionne que lorsque nous connaissons le nom de la classe et que la classe a un constructeur public par défaut.
Dans le programme suivant, nous avons créé un nouvel objet en utilisant la méthode newInstance().
CreateObjectExample4.java
public class CreateObjectExample4 { void show() { System.out.println('A new object created.'); } public static void main(String[] args) { try { //creating an instance of Class class Class cls = Class.forName('CreateObjectExample4'); //creates an instance of the class using the newInstance() method CreateObjectExample4 obj = (CreateObjectExample4) cls.newInstance(); //invoking the show() method obj.show(); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } } } Sortir:
Android peut-il jouer à GamePigeon
A new object created.
Utilisation de la méthode newInstance() de la classe Constructor
C'est semblable au nouvelleInstance() méthode du Classe classe. C’est une manière réflexive de créer des objets. La méthode est définie dans le Constructeur classe qui est la classe dejava.lang.reflectemballer. Nous pouvons également appeler le constructeur paramétré et le constructeur privé en utilisant le nouvelleInstance() méthode. Elle est largement préférée par rapport à la méthode newInstance() de la classe Class.
Syntaxe:
public T newInstance(Object... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
La méthode analyse un tableau d'objets comme argument. Les valeurs des types primitifs enveloppés dans un objet wrapper du type approprié. Il renvoie un nouvel objet créé en appelant le constructeur. Ça jette IllegalAccessException, IllegalArgumentException, InstantiationException, InvocationTargetException, ExceptionInInitializerError Exceptions .
Nous pouvons créer un objet de la manière suivante :
Constructor constructor = Employee.class.getConstructor(); Employee emp3 = constructor.newInstance();
Créons un programme qui crée un objet en utilisant la méthode newInstance().
CreateObjectExample5.java
import java.lang.reflect.*; public class CreateObjectExample5 { private String str; CreateObjectExample5() { } public void setName(String str) { this.str = str; } public static void main(String[] args) { try { Constructor constructor = CreateObjectExample5.class.getDeclaredConstructor(); CreateObjectExample5 r = constructor.newInstance(); r.setName('JavaTpoint'); System.out.println(r.str); } catch (Exception e) { e.printStackTrace(); } } } Sortir:
JavaTpoint
Utiliser la désérialisation
En Java, sérialisation est le processus de conversion d'un objet en une séquence de flux d'octets. Le processus inverse (flux d'octets vers objet) de sérialisation est appelé désérialisation . La JVM crée un nouvel objet lorsque nous sérialisons ou désérialisons un objet. Il n'utilise pas de constructeur pour créer un objet. En utilisant la désérialisation, le Sérialisable L'interface (interface de marqueur) doit être implémentée dans la classe.
Sérialisation : Le writeObject() méthode du ObjetOutputStream la classe est utilisée pour sérialiser un objet. Il envoie l'objet au flux de sortie.
Syntaxe:
nombre à chaîne java
public final void writeObject(object x) throws IOException
Désérialisation : La méthode readObject() de ObjetInputStream la classe est utilisée pour désérialiser un objet. Il référence des objets hors d'un flux.
Syntaxe:
public final Object readObject() throws IOException,ClassNotFoundException
Remarque : rendez le champ statique ou transitoire si nous ne souhaitons pas inclure de champ dans l'objet. Il ne sera pas inclus dans le processus de sérialisation.
Comprenons la sérialisation et la désérialisation à travers un programme.
Employé.java
import java.io.Serializable; public class Employee implements Serializable { int empid; String empname; public Empoyee(int empid, String empname) { this.empid = empid; this.empname = empname; } } Nous avons créé une classe nommée Employé dont l'objet est à sérialiser et désérialiser.
Sérialisation de l'objet Java :
Dans le programme suivant, nous avons sérialisé un objet de la classe Employee en utilisant le writeObject() méthode de la classe ObjectOutputStream. L'état de l'objet est enregistré dans le employé.txt déposer.
SerializationExample.java
import java.io.*; class SerializationExample { public static void main(String args[]) { Try { //Creating the object Employee emp = new Employee(198054,'Andrew'); //Creates a stream and writes the object FileOutputStream fout=new FileOutputStream('employee.txt'); ObjectOutputStream out=new ObjectOutputStream(employeeout); out.writeObject(emp); out.flush(); //closes the output stream out.close(); System.out.println('Successfully Created'); } catch(Exception e) { System.out.println(e); } } } Sortir:
dans.suivant java
Successfully Created
Désérialisation d'un objet Java :
Dans le programme suivant, nous allons désérialiser un objet que nous avons sérialisé dans le programme ci-dessus.
DésérialisationExample.java
import java.io.*; class DeserializationExample { public static void main(String args[]) { try { //Creating a stream to read the object ObjectInputStream in=new ObjectInputStream(new FileInputStream('employee.txt')); Employee e=(Employee)in.readObject(); //prints the data of the serialized object System.out.println(e.empid+' '+e.empname); //closing the input stream in.close(); } catch(Exception e) { System.out.println(e); } } } Sortir:
198054 Andrew
Dans les cinq méthodes ci-dessus, nous avons remarqué que le nouveau mot-clé et les deux nouvelleInstance() Les méthodes utilisent le constructeur pour créer des objets, tandis que les deux autres méthodes n'utilisent pas le constructeur.