marker interface java
Ce didacticiel explique ce qu'est une interface de marqueur en Java. Il couvre également la désérialisation et le clonage de sérialisation en Java avec des exemples de code:
Nous aborderons le dernier sujet sous Interfaces, c'est-à-dire l'interface des marqueurs en Java.
Une fois que nous en avons terminé avec l'interface de marqueur, nous discuterons de deux exemples, à savoir l'interface sérialisable et clonable en Java. Commençons par l'interface Marker.
=> Visitez ici pour apprendre Java à partir de zéro
Ce que vous apprendrez:
- Interface de marqueur en Java
- Sérialisation en Java
- Interface sérialisable Java
- Interface clonable en Java
- Conclusion
Interface de marqueur en Java
Une interface de marqueur en Java est une interface vide qui n'a ni champs ni méthodes. Cette interface de marqueur indique au compilateur que les objets de la classe qui implémentent l'interface de marqueur sont différents et qu'ils doivent être traités différemment.
Chaque interface de marqueur en Java indique qu'elle représente quelque chose de spécial pour la JVM ou le compilateur.
En Java, nous avons trois interfaces qui sont des interfaces Marker, comme indiqué ci-dessous:
# 1) Interface sérialisable: Serializable est une interface de marqueur présente dans le package java.io. Nous pouvons sérialiser des objets en utilisant cette interface, c'est-à-dire enregistrer l'état de l'objet dans un fichier.
# 2) Interface clonable: L'interface clonable fait partie du package java.lang et permet aux objets d'être clonés.
# 3) Interface à distance: L'interface distante fait partie du package java.RMI et nous utilisons cette interface pour créer des applications RMI. Cette interface traite principalement des objets distants.
Dans ce tutoriel, nous discuterons de l'interface sérialisable et clonable. L'interface distante sera discutée lorsque nous passerons à RMI en Java.
Sérialisation en Java
Avant d'entrer dans les détails de l'interface sérialisable en Java, comprenons le processus de sérialisation ainsi que la désérialisation en Java.
La sérialisation peut être définie comme un processus par lequel nous convertissons l'état de l'objet en son flux d'octets équivalent pour stocker l'objet dans la mémoire dans un fichier ou persister L'object.
Lorsque nous voulons récupérer l'objet à partir de son état enregistré et accéder à son contenu, nous devrons reconvertir le flux d'octets en l'objet Java réel et ce processus s'appelle la désérialisation.
De cette façon, il peut y avoir de nombreuses instances dans lesquelles nous devons sérialiser / désérialiser des objets Java au cours de la vie d'une application Java.
Le processus de sérialisation / désérialisation est illustré ci-dessous:
Comme indiqué ci-dessus, la sérialisation convertit l'objet en un flux. La désérialisation reconvertit le flux d'octets en objet Java.
L'ensemble du mécanisme de sérialisation et de désérialisation est indépendant de la plate-forme. Cela signifie que nous pouvons sérialiser l'objet sur une plate-forme, puis le désérialiser sur une plate-forme différente.
Quand nous disons que nous avons sérialisé l'objet Java, cela signifie que nous avons appelé la méthode ObjectOutputStream writeObject () pour écrire l'objet dans un fichier.
La clé de sécurité du réseau est-elle la même que le mot de passe wifi
public final void writeObect (Object obj) lève IOException
De même, dans le cas de la désérialisation, nous appelons la méthode ObjectInputStream :: readObject () pour lire les données du fichier qui a stocké l'objet.
Public final Object readObject () lève IOException, ClassNotFoundException
Interface sérialisable Java
Java fournit l'interface nommée «sérialisable» à l'aide de laquelle nous pouvons implémenter la sérialisation et la désérialisation en Java.
L'interface sérialisable fait partie du package java.io. C'est un exemple d'interface de marqueur dont nous avons discuté ci-dessus et qui n'a ni méthodes ni membres. L'interface sérialisable «marque» les classes Java afin que les objets de ces classes aient la capacité de persister.
Ainsi, la classe dont nous devons conserver l'objet doit implémenter l'interface Serializable. Ensuite, l'objet de cette classe (implémentant l'interface Serializable) utilisera respectivement les méthodes writeObject () et readObject () pour sérialiser et désérialiser l'objet de classe.
Notez que toutes les classes wrapper et la classe String implémentent le java.io.Serializable par défaut.
Nous devons remplir la condition suivante pour qu'un objet soit sérialisé avec succès:
- La classe dont les objets sont sérialisés doit implémenter l'interface java.io.Serializable.
- Tous les champs membres de la classe doivent être sérialisables. Si un champ particulier n'est pas sérialisable, nous devons le marquer comme transitoire.
Inversement, une classe n'est sérialisable que si elle implémente l'interface java.io.Serializable sinon elle n'est pas sérialisable.
Comment sérialiser et désérialiser un objet en Java
Lorsque nous sérialisons un objet en Java, nous utilisons la méthode writeObject d’objectOutputStream pour écrire l’objet dans un fichier.
Pour désérialiser l'objet en Java, nous utilisons la méthode readObject () d'ObjectInputStream pour lire le contenu du fichier et le lire dans un objet.
Dans cet exemple, nous avons une classe Student qui implémente l'interface Serializable. Cela signifie que nous pouvons sérialiser ou désérialiser les objets de la classe Student.
Dans la méthode principale du programme Java, nous créons un objet de classe Student. Ensuite, nous créons un ObjectOutputStream qui pointe vers un objet FileOutputStream qui à son tour pointe vers un fichier dans lequel nous devons écrire l'objet Student. Ensuite, nous appelons la méthode writeObject () qui écrit l'objet dans le fichier.
Lors de l'écriture réussie de l'objet spécifié dans le fichier spécifié, le programme donne un message de sortie approprié. Nous désérialisons ensuite l'objet en inversant le processus ci-dessus. Tout d'abord, nous créons un objet ObjectOutputStream dans lequel nous lisons le fichier dont le contenu doit être lu.
Nous utilisons ensuite la méthode readObject () pour lire le contenu et le convertir en objet Student. Ensuite, nous imprimons le contenu de l'objet Student.
Exemple de sérialisation / désérialisation
Le programme Java suivant montre le mécanisme de sérialisation / désérialisation en Java comme indiqué ci-dessus.
import java.io.*; import java.io.Serializable; //Class Student implements class Student implements Serializable{ int id; String name; public Student(int id, String name) { this.id = id; this.name = name; } } class Main{ public static void main(String args()){ try{ //Create the object of student class Student s1 =new Student(27,'Eddie'); //Write the object to the stream by creating a output stream FileOutputStream fout=new FileOutputStream('Eddie.txt'); ObjectOutputStream out=new ObjectOutputStream(fout); out.writeObject(s1); out.flush(); //close the stream out.close(); System.out.println('Object successfully written to the file'); //Create a stream to read the object ObjectInputStream in=new ObjectInputStream(new FileInputStream('Eddie.txt')); Student s=(Student)in.readObject(); //print the data of the deserialized object System.out.println('Student object: ' + s.id+' '+s.name); //close the stream in.close(); }catch(Exception e){System.out.println(e);} } } Production:
Notez qu'après la désérialisation, nous obtenons le même objet que nous avons sérialisé précédemment lorsque nous ouvrons à nouveau le même fichier.
Mot-clé transitoire Java
Un mot clé transitoire est utilisé pour rendre un membre de données transitoire, c'est-à-dire que nous ne voulons pas le sérialiser.
Par exemple, considérez la classe d'employé suivante. Ici, nous avons le champ d'identification de l'employé avec les autres champs. Maintenant, si nous décidons que le champ de l’identifiant de l’employé ne doit pas être sérialisé, nous le déclarons comme «transitoire».
Un exemple de programme Java est donné ci-dessous.
import java.io.*; class Employee implements Serializable{ transient int id; String name; public Employee(int id, String name) { this.id = id; this.name = name; } } class Main{ public static void main(String args()){ try{ //Create the object of Employee class Employee s1 =new Employee(27,'Eddie'); //Write the object to the stream by creating a output stream FileOutputStream fout=new FileOutputStream('Eddie.txt'); ObjectOutputStream out=new ObjectOutputStream(fout); out.writeObject(s1); out.flush(); //close the stream out.close(); System.out.println('Object successfully written to the file'); //Create a stream to read the object ObjectInputStream in=new ObjectInputStream(new FileInputStream('Eddie.txt')); Employee s=(Employee)in.readObject(); //print the data of the deserialized object System.out.println('Employee object: ' + s.id+' '+s.name); //close the stream in.close(); }catch(Exception e){System.out.println(e);} } } Production:
Dans le programme ci-dessus, nous avons sérialisé l'objet Employee. Mais notez que le champ Employee id de la classe Employee est déclaré «transitoire». Maintenant, pour vérifier la sérialisation, nous désérialisons l'objet. La sortie affiche l’objet Employé sous la forme «0 Eddie». Cela signifie que l'ID d'employé n'a pas été enregistré dans le fichier.
Java.io.NotSerializableException en Java
L'exception de java.io.NotSerializableException est une exception levée lorsque la classe n'est pas éligible pour la sérialisation. La classe qui n'implémente pas l'interface Serializable devient inéligible pour la sérialisation.
Le programme Java ci-dessous illustre l'exception NotSerializableException.
import java.io.*; class Employee { transient int id; String name; public Employee(int id, String name) { this.id = id; this.name = name; } } class Main{ public static void main(String args()){ try{ //Create the object of Employee class Employee s1 =new Employee(27,'Eddie'); //Write the object to the stream by creating a output stream FileOutputStream fout=new FileOutputStream('Eddie.txt'); ObjectOutputStream out=new ObjectOutputStream(fout); out.writeObject(s1); out.flush(); //close the stream out.close(); System.out.println('Object successfully written to the file'); }catch(Exception e){System.out.println(e);} } } Production:
Comme vu du programme ci-dessus, la classe Employee n'implémente pas l'interface Serializable. Par conséquent, lorsque nous essayons de sérialiser l'objet de classe Employee, l'exception NotSerializableException est levée.
Interface clonable en Java
Le clonage d'objets signifie faire une copie des objets. Java prend en charge le clonage d'objets à l'aide du ' Clonable »Interface. L'interface clonable est une interface de marqueur et fait partie du package java.lang.
Lorsqu'une classe implémente l'interface clonable, cela implique que nous pouvons cloner les objets de cette classe. La classe Object de Java contient le ‘ cloner ()' méthode. Ainsi, l'interface clonable implémentée par une classe particulière autorise la méthode clone () à faire des copies des instances de classe.
Si une classe n'implémente pas une interface clonable et appelle toujours la méthode clone (), alors l'exception CloneNotSupportedException est lancé par le compilateur Java.
Les classes implémentant l'interface clonable doivent remplacer la méthode clone ().
Alors, qu'est-ce que le clonage d'objets?
Le clonage d'objets est un processus par lequel nous créons une copie exacte de l'objet en utilisant la méthode clone () de la classe Object. Pour que la méthode clone () soit remplacée et appelée, la classe doit implémenter l'interface clonable.
La syntaxe générale de la méthode clone () est donnée ci-dessous:
protégé Clone d'objet () jette CloneNotSupportedException
La méthode clone () crée une copie exacte de l'objet avec moins de temps de traitement que celui nécessaire pour créer un nouvel objet à l'aide du mot-clé new.
Le programme Java ci-dessous illustre l'utilisation de la méthode clone () et de l'interface clonable.
class Student implements Cloneable{ int rollno; String name; //class constructor Student(int rollno,String name){ this.rollno=rollno; this.name=name; } //clone method public Object clone()throws CloneNotSupportedException{ return super.clone(); } } class Main{ public static void main(String args()){ try{ Student s1=new Student(101,'Lissa'); //clone the s1 object Student s2=(Student)s1.clone(); System.out.println('Original Student object: ' + s1.rollno+' '+s1.name); System.out.println('Cloned Student object: ' + s2.rollno+' '+s2.name); }catch(CloneNotSupportedException c){} } } Production:
Dans ce programme, nous avons une classe Student implémentant l'interface clonable. Il remplace également la méthode clone () en appelant la méthode super.clone (). Dans la méthode principale, nous créons un nouvel objet Student, puis appelons la méthode clone () sur cet objet qui renvoie le nouvel objet Student.
Cloner un tableau en Java
Nous avons exploré le clonage de tableaux dans notre tutoriel sur les tableaux. Étant donné que les baies Java implémentent une interface clonable par défaut, elles n'ont pas besoin d'être implémentées explicitement. Lorsque le tableau unidimensionnel est cloné, une copie complète du tableau est générée. Lorsqu'un tableau bidimensionnel est cloné, une copie superficielle est effectuée.
Faire une copie superficielle est le comportement par défaut de la méthode clone () en Java. Mais la plupart du temps, nous souhaitons un clonage en profondeur. Dans le clonage profond, nous faisons une copie de l'objet membre par membre et créons un clone indépendant de l'objet d'origine. Les modifications apportées ensuite à l'objet clone ne seront pas reflétées dans l'objet d'origine.
Le programme Java suivant montre le clonage d'un tableau unidimensionnel.
class Main { public static void main(String args()) { //define an array int intArray() = {2,6,3,7,1,8}; //invoke clone () method on intArray int cloneArray() = intArray.clone(); //print the arrays. System.out.println('Original intArray:'); for (int i = 0; i Production:
Liste de clonage en Java
Le programme ci-dessous montre comment utiliser une méthode clone () pour cloner une liste en Java.
import java.util.ArrayList; import java.util.Arrays; import java.util.List; // MyList Class implementing cloneable class MyList implements Cloneable { String name1; String name2; // Constructor MyList(String name1, String name2) { this.name1 = name1; this.name2 = name2; } // To print the objects in the desired format @Override public String toString() { return 'Hello ' + name1 + ',' + name2 + '
' ; } // Overriding the clone method @Override protected MyList clone() { return new MyList(name1 , name2); } } class Main { public static void main(String() args) { // Create a list List original = Arrays.asList( new MyList('Sydney','Rose'), new MyList('Joe','Ian')); // Create an empty list List cloned_list = new ArrayList(); // Loop through the list and clone each element for (MyList temp : original) cloned_list.add(temp.clone()); System.out.print(cloned_list); } } Production:
Dans le programme ci-dessus, nous voyons que nous avons créé une classe MyList qui implémente l'interface clonable et à l'intérieur de cette classe, nous remplaçons la méthode clone () qui nous aide à cloner la liste. Dans la méthode principale, nous créons une liste d'éléments puis clonons chaque élément de la liste en itérant sur la liste.
Questions fréquemment posées
Q # 1) Quelle est l'utilisation de Marker Interface en Java?
Répondre: L'interface de marqueur également connue sous le nom «d'interface étiquetée» marque la classe et informe le compilateur que cette classe peut implémenter un comportement spécial.
Q # 2) Quelles sont toutes les interfaces de marqueurs en Java?
Répondre: Serializable, Cloneable et Remote sont les interfaces qui sont des exemples d'interfaces de marqueurs en Java.
Q # 3) Pourquoi sérialisable une interface de marqueur?
Répondre: L'interface sérialisable n'a aucune méthode ou variable membre. C'est une interface vide qui la classe comme une interface de marqueur.
Q # 4) Est-ce qu'une interface de marqueur est exécutable?
Répondre: Non, runnable n'est pas une interface de marqueur. L'interface exécutable n'est pas vide et elle contient une déclaration de méthode run ().
Q # 5) Pourquoi avons-nous besoin d'implémenter une interface clonable?
Répondre: En implémentant une interface clonable pour une classe, nous indiquons que les objets de cette classe peuvent être clonés en utilisant la méthode clone () de la classe Object. Si une classe utilisant la méthode clone () n’implémente pas d’interface clonable, l’exception «CloneNotSupportedException» est lancée.
Conclusion
Avec ce tutoriel, nous avons terminé notre discussion sur les interfaces en Java. Nous avons discuté du concept des interfaces, de leur structure, de leur définition, de leur utilisation, etc. Nous avons également discuté de certaines des interfaces importantes dans les interfaces de type Java Comparable, Comparator, Marker, etc.
Dans ce didacticiel, nous avons discuté de deux exemples d'interfaces de marqueurs, c'est-à-dire sérialisables et clonables. Une interface sérialisable est utilisée pour conserver un objet. L'interface clonable est utilisée pour cloner les objets de classe. Ces deux interfaces sont des interfaces de marqueurs, c'est-à-dire qu'elles sont vides.
Mais lorsqu'une classe les implémente, alors ils indiquent que le compilateur peut s'attendre à un comportement spécial de la part des classes qui les implémentent.
Par exemple, lorsqu'une classe implémente une interface sérialisable, nous pouvons sérialiser ou désérialiser les objets de classe et enregistrer / récupérer leur état.
Une classe implémentant une interface clonable indique que nous pouvons cloner les objets de cette classe. L'implémentation par défaut de la méthode clone () crée une copie superficielle de l'objet tandis que nous pouvons remplacer la méthode clone () pour créer une copie profonde.
=> Découvrez la série complète de formations Java ici
lecture recommandée
- Définir l'interface en Java: didacticiel sur le jeu Java avec des exemples
- Interface ListIterator en Java avec des exemples
- Déploiement Java: création et exécution d'un fichier JAR Java
- Et le Java - et sa mise en œuvre et ses définitions
- Principes de base de Java: syntaxe Java, classe Java et principaux concepts Java
- Objet Java Class Vs - Comment utiliser une classe et un objet en Java
- Machine virtuelle Java: comment JVM aide à exécuter une application Java
- Interfaces comparables et comparatives en Java
