marker interface java
Aquest tutorial explica què és una interfície de marcador a Java. També cobreix la deserialització i la clonació de la serialització en Java amb exemples de codi:
Debatrem sobre l’últim tema a Interfaces, és a dir, Marker Interface a Java.
Un cop hàgim acabat la interfície de marcador, parlarem de dos exemples, és a dir, interfície serialitzable i clonable a Java. Comencem per la interfície del marcador.
=> Visiteu aquí per aprendre Java des de zero
Què aprendreu:
- Interfície de marcador a Java
- Serialització a Java
- Interfície serialitzable de Java
- Interfície clonable a Java
- Conclusió
Interfície de marcador a Java
Una interfície de marcador a Java és una interfície buida que no té camps ni mètodes. Aquesta interfície de marcador indica al compilador que els objectes de la classe que implementen la interfície de marcador són diferents i que s'han de tractar de manera diferent.
Cada interfície de marcador a Java indica que representa alguna cosa especial per a JVM o compilador.
A Java, tenim tres interfícies que són interfícies Marker, tal com es mostra a continuació:
# 1) Interfície serialitzable: Serializable és una interfície de marcador present al paquet java.io. Podem serialitzar objectes mitjançant aquesta interfície, és a dir, desar l’estat de l’objecte en un fitxer.
# 2) Interfície clonable: La interfície clonable forma part del paquet java.lang i permet clonar els objectes.
# 3) Interfície remota: La interfície remota forma part del paquet java.RMI i utilitzem aquesta interfície per crear aplicacions RMI. Aquesta interfície tracta principalment d'objectes remots.
En aquest tutorial, parlarem de la interfície serialitzable i clonable. La interfície remota es discutirà quan passem a RMI a Java.
Serialització a Java
Abans d’entrar en els detalls de la interfície serialitzable a Java, comprenguem el procés de serialització i la deserialització a Java.
La serialització es pot definir com un procés mitjançant el qual convertim l'estat de l'objecte en el seu flux de bytes equivalent per emmagatzemar l'objecte a la memòria en un fitxer o persistir l'objecte.
Quan volem recuperar l'objecte del seu estat desat i accedir al seu contingut, haurem de convertir el flux de bytes de nou a l'objecte Java real i aquest procés s'anomena deserialització.
D'aquesta manera, pot haver-hi molts casos en què necessitem serialitzar / deserialitzar objectes Java durant tota la vida de l'aplicació Java.
A continuació es mostra el procés de serialització / deserialització:
Com es mostra més amunt, la serialització converteix l'objecte en un flux. La deserialització converteix el flux de bytes de nou en un objecte Java.
Tot el mecanisme de serialització i deserialització és independent de la plataforma. Això significa que podem serialitzar l'objecte en una plataforma i després deserialitzar-lo en una plataforma diferent.
Quan diem que hem serialitzat l'objecte Java, vol dir que hem cridat el mètode ObjectOutputStream writeObject () per escriure l'objecte a un fitxer.
aplicació gratuïta de descàrrega de mp3 per a telèfons Android
public final void writeObect (object obj) llança IOException
De la mateixa manera, en el cas de la deserialització, anomenem el mètode ObjectInputStream :: readObject () per llegir les dades del fitxer que ha emmagatzemat l'objecte.
public final Object readObject () llança IOException, ClassNotFoundException
Interfície serialitzable de Java
Java proporciona la interfície anomenada 'serialitzable' mitjançant la qual podem implementar la serialització i la deserialització a Java.
La interfície serialitzable forma part del paquet java.io. És un exemple d'una interfície de marcador que hem comentat anteriorment i 0 que no té mètodes ni membres. La interfície serialitzable «marca» les classes Java de manera que els objectes d’aquestes classes tinguin la capacitat de persistir.
Per tant, la classe l'objecte de la qual hem de persistir hauria d'implementar la interfície serialitzable. Llavors, l'objecte d'aquesta classe (implementant la interfície Serializable) utilitzarà mètodes writeObject () i readObject () respectivament per serialitzar i deserialitzar l'objecte de classe.
Tingueu en compte que totes les classes wrapper i la classe String implementen java.io.Serializable per defecte.
Perquè un objecte es serialitzi correctament, hauríem de complir les condicions següents:
- La classe els objectes dels quals estan serialitzats ha d'implementar la interfície java.io.Serializable.
- Tots els camps membres de la classe han de ser serialitzables. Si un camp concret no es pot serialitzar, hauríem de marcar-lo com a transitori.
Per contra, una classe només es pot serialitzar si implementa la interfície java.io.Serializable, en cas contrari no es pot serialitzar.
Com serialitzar i deserialitzar un objecte a Java
Quan serialitzem un objecte a Java, fem servir el mètode writeObject d’objectOutputStream per escriure l’objecte en un fitxer.
Per deserialitzar l’objecte a Java, fem servir el mètode readObject () de ObjectInputStream per llegir el contingut del fitxer i llegir-los en un objecte.
En aquest exemple, tenim una classe Student que implementa la interfície serialitzable. Això significa que podem serialitzar o deserialitzar els objectes de la classe Student.
Al mètode principal del programa Java, creem un objecte de classe Student. A continuació, creem un ObjectOutputStream que apunta a un objecte FileOutputStream que al seu torn apunta a un fitxer en el qual hem d’escriure l’objecte Student. A continuació, anomenem el mètode writeObject () que escriu l'objecte al fitxer.
En escriure correctament l’objecte especificat al fitxer especificat, el programa emet un missatge de sortida adequat. A continuació, deserialitzem l'objecte invertint el procés anterior. En primer lloc, creem un objecte ObjectOutputStream en el qual llegim el fitxer el contingut del qual s’ha de llegir.
A continuació, fem servir el mètode readObject () per llegir el contingut i enviar-lo a l'objecte Student. A continuació, imprimim el contingut de l'objecte Student.
Exemple de serialització / deserialització
El següent programa Java mostra el mecanisme de serialització / deserialització a Java, tal com s’ha comentat anteriorment.
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);} } } Sortida:
Tingueu en compte que després de la deserialització, obtenim el mateix objecte que hem serialitzat anteriorment en obrir de nou el mateix fitxer.
Paraula clau transitòria Java
S'utilitza una paraula clau transitòria per fer que un membre de dades sigui transitori, és a dir, no volem serialitzar-la.
Per exemple, tingueu en compte la classe següent Empleat. Aquí tenim el camp Identificador d'empleat juntament amb els altres camps. Ara bé, si decidim que el camp Identificador d'empleat no s'ha de serialitzar, el declarem com a 'transitori'.
A continuació es mostra un exemple de programa Java.
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);} } } Sortida:
Al programa anterior, hem serialitzat l'objecte Employee. Tingueu en compte que el camp Identificador d'empleat de la classe Employee es declara 'transitori'. Ara per comprovar la serialització, deserialitzem l'objecte. La sortida mostra l'objecte Employee com a '0 Eddie'. Això significa que l'identificador d'empleat no s'ha desat al fitxer.
Java.io.NotSerializableException A Java
L'excepció de java.io.NotSerializableException és una excepció que es genera quan la classe no és apta per a la serialització. La classe que no implementa la interfície serialitzable no és apta per a la serialització.
El programa Java següent mostra l’Excepció NotSerializable.
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);} } } Sortida:
Tal com es veu al programa anterior, la classe Employee no implementa la interfície serializable. Per tant, quan intentem serialitzar l’objecte de la classe Employee, es llança NotSerializableException.
Interfície clonable a Java
Clonar objectes significa fer una còpia dels objectes. Java admet la clonació d'objectes mitjançant Clonable ”Interfície. La interfície clonable és una interfície de marcador i forma part del paquet java.lang.
Quan una classe implementa la interfície Cloneable, implica que podem clonar els objectes d’aquesta classe. La classe Object de Java conté el text ‘ clonar () ’Mètode. Per tant, la interfície clonable implementada per una classe particular autoritza el mètode clone () a fer còpies d’instàncies de classe.
Si una classe no implementa una interfície clonable i continua invocant el mètode clone (), l'excepció CloneNotSupportedException és llançat pel compilador Java.
Les classes que implementen la interfície Cloneable haurien de substituir el mètode clone ().
Llavors, què és la clonació d'objectes?
La clonació d'objectes és un procés mitjançant el qual creem una còpia exacta de l'objecte mitjançant el mètode clone () de la classe Object. Perquè el mètode clone () es pugui anul·lar i invocar, la classe ha d'implementar la interfície Cloneable.
A continuació es mostra la sintaxi general del mètode clone ():
protegit Clon d'objectes () llança CloneNotSupportedException
El mètode clone () crea una còpia exacta de l'objecte amb menys temps de processament que el necessari per crear un nou objecte amb la nova paraula clau.
El programa Java següent mostra l’ús del mètode clone () i de la interfície Cloneable.
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){} } } Sortida:
En aquest programa, tenim una classe Student que implementa la interfície Cloneable. També substitueix el mètode clone () trucant al mètode super.clone (). Al mètode principal creem un nou objecte Student i després cridem al mètode clone () en aquest objecte que retorna el nou objecte Student.
Clon Array a Java
Hem explorat la clonació de matrius al nostre tutorial sobre matrius. Com que les matrius Java implementen la interfície Cloneable per defecte, no cal que s’implementin explícitament. Quan es clona la matriu unidimensional, es genera una còpia profunda de la matriu. Quan es clona una matriu bidimensional, es fa una còpia poc profunda.
Fer una còpia superficial és el comportament predeterminat del mètode clone () a Java. Però la majoria de les vegades desitgem una clonació profunda. En la clonació profunda, fem una còpia de l'objecte membre per membre i creem un clon que és independent de l'objecte original. Qualsevol canvi que es faci a l'objecte clon no es reflectirà a l'objecte original.
El següent programa Java mostra la clonació d'una matriu unidimensional.
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 Sortida:
Llista de clons a Java
El programa següent mostra com utilitzar un mètode clone () per clonar una llista a 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); } } Sortida:
Al programa anterior, veiem que hem creat una classe MyList que implementa la interfície Cloneable i, dins d'aquesta classe, substituïm el mètode clone () que ens ajuda a clonar la llista. Al mètode principal, creem una llista d'elements i, a continuació, clonem cada element de la llista iterant sobre la llista.
Preguntes freqüents
P # 1) Què utilitza Marker Interface a Java?
Resposta: La interfície de marcador que també es coneix com a 'interfície etiquetada' etiqueta la classe i informa el compilador que aquesta classe pot implementar un comportament especial.
Q # 2) Quines són totes les interfícies de marcador a Java?
Resposta: Serializable, Cloneable i Remote són les interfícies que són els exemples d'interfícies de marcador a Java.
P # 3) Per què es pot serialitzar una interfície de marcador?
Resposta: La interfície serialitzable no té cap mètode ni variable membre. És una interfície buida que la classifica com a interfície de marcador.
P # 4) És executable una interfície de marcador?
Resposta: No, runnable no és una interfície de marcador. La interfície executable no està buida i proporciona una declaració del mètode run () al seu interior.
Q # 5) Per què necessitem implementar una interfície clonable?
Resposta: En implementar una interfície clonable per a una classe, indiquem que els objectes d’aquesta classe es poden clonar mitjançant el mètode clone () de la classe Object. Si una classe que utilitza el mètode clone () no implementa una interfície clonable, es genera l'excepció 'CloneNotSupportedException'.
Conclusió
Amb aquest tutorial, hem completat la nostra discussió sobre les interfícies a Java. Hem discutit el concepte d'interfícies, la seva estructura, definició, ús, etc. També hem debatut sobre algunes de les interfícies importants en interfícies comparables, comparadores, marcadores, com ara Java.
En aquest tutorial, hem discutit dos exemples d'interfícies de marcador, és a dir, serialitzables i clonables. S'utilitza una interfície serialitzable per persistir un objecte. La interfície clonable s’utilitza per clonar els objectes de la classe. Ambdues interfícies són interfícies marcadores, és a dir, estan buides.
Però quan una classe els implementa, aleshores indiquen que el compilador pot esperar un comportament especial de les classes que els implementin.
Per exemple, quan una classe implementa una interfície serialitzable, podem serialitzar o deserialitzar els objectes de la classe i desar / recuperar el seu estat.
Una classe que implementa una interfície clonable indica que podem clonar els objectes d’aquesta classe. La implementació per defecte del mètode clone () crea una còpia superficial de l’objecte mentre podem substituir el mètode clone () per crear una còpia profunda.
=> Exploreu aquí la sèrie de formació completa de Java
Lectura recomanada
- Configuració de la interfície a Java: Tutorial de configuració de Java amb exemples
- Interfície ListIterator a Java amb exemples
- Desplegament de Java: creació i execució del fitxer JAR de Java
- I Java - i la seva implementació i definicions
- Conceptes bàsics de Java: sintaxi de Java, Java Class i conceptes bàsics de Java
- Objecte Java Class Vs: com s'utilitza la classe i l'objecte a Java
- Màquina virtual Java: com ajuda JVM a executar aplicacions Java
- Interfícies comparables i comparadores a Java
