Menu

Marker Interface in Java: serializzabile e clonabile

marker interface java

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo tutorial spiega cos'è una Marker Interface in Java. Copre anche la deserializzazione della serializzazione e la clonazione in Java con esempi di codice:

Discuteremo l'ultimo argomento in Interfacce, ovvero Marker Interface in Java.

Dopo aver terminato con l'interfaccia marker, discuteremo due esempi, ovvero l'interfaccia serializzabile e clonabile in Java. Cominciamo con l'interfaccia Marker.

=> Visita qui per imparare Java da zero

Marker Interfaces in Java - Serializzabile e clonabile

Cosa imparerai:

Marker Interface In Java

Un'interfaccia marker in Java è un'interfaccia vuota che non ha campi o metodi. Questa interfaccia marker indica al compilatore che gli oggetti della classe che implementano l'interfaccia marker sono diversi e che dovrebbero essere trattati in modo diverso.

Ogni interfaccia marker in Java indica che rappresenta qualcosa di speciale per JVM o compilatore.

In Java, abbiamo tre interfacce che sono interfacce Marker come mostrato di seguito:

# 1) Interfaccia serializzabile: Serializable è un'interfaccia marker presente nel pacchetto java.io. Possiamo serializzare gli oggetti usando questa interfaccia, cioè salvare lo stato dell'oggetto in un file.

# 2) Interfaccia clonabile: L'interfaccia clonabile fa parte del pacchetto java.lang e consente la clonazione degli oggetti.

# 3) Interfaccia remota: L'interfaccia remota è una parte del pacchetto java.RMI e usiamo questa interfaccia per creare applicazioni RMI. Questa interfaccia si occupa principalmente di oggetti remoti.

In questo tutorial, discuteremo l'interfaccia serializzabile e clonabile. L'interfaccia remota verrà discussa quando si passerà a RMI in Java.

Serializzazione in Java

Prima di entrare nei dettagli dell'interfaccia Serializable in Java, vediamo di capire il processo di serializzazione e deserializzazione in Java.

La serializzazione può essere definita come un processo mediante il quale convertiamo lo stato dell'oggetto nel suo flusso di byte equivalente per memorizzare l'oggetto nella memoria in un file o persistere l'oggetto.

Quando vogliamo recuperare l'oggetto dal suo stato salvato e accedere al suo contenuto, dovremo riconvertire il flusso di byte nell'oggetto Java effettivo e questo processo è chiamato deserializzazione.

In questo modo potrebbero esserci molti casi in cui abbiamo bisogno di serializzare / deserializzare oggetti Java in una durata dell'applicazione Java.

Il processo di serializzazione / deserializzazione è mostrato di seguito:

serializzazione O deserializzazione

Come mostrato sopra, la serializzazione converte l'oggetto in un flusso. La deserializzazione converte il flusso di byte in un oggetto Java.

L'intero meccanismo di serializzazione e deserializzazione è indipendente dalla piattaforma. Ciò significa che possiamo serializzare l'oggetto su una piattaforma e quindi deserializzarlo su una piattaforma diversa.

Quando diciamo che abbiamo serializzato l'oggetto Java, significa che abbiamo chiamato il metodo ObjectOutputStream writeObject () per scrivere l'oggetto su un file.

come trovare la chiave di sicurezza di rete sul mio computer

public final void writeObect (Object obj) genera IOException

Allo stesso modo, nel caso della deserializzazione, chiamiamo il metodo ObjectInputStream :: readObject () per leggere i dati dal file che ha memorizzato l'oggetto.

public final Object readObject () genera IOException, ClassNotFoundException

Interfaccia serializzabile Java

Java fornisce l'interfaccia denominata 'serializzabile' che consente di implementare la serializzazione e la deserializzazione in Java.

L'interfaccia serializzabile fa parte del pacchetto java.io. È un esempio di un'interfaccia marker di cui abbiamo discusso in precedenza e 0 che non ha metodi o membri. L'interfaccia serializzabile 'contrassegna' le classi Java in modo che gli oggetti di queste classi abbiano la capacità di persistere da soli.

Quindi la classe di cui dobbiamo rendere persistente l'oggetto dovrebbe implementare l'interfaccia Serializable. Quindi l'oggetto di questa classe (che implementa l'interfaccia Serializable) utilizzerà i metodi writeObject () e readObject () rispettivamente per serializzare e deserializzare l'oggetto della classe.

Notare che tutte le classi wrapper e la classe String implementano java.io.Serializable per impostazione predefinita.

È necessario soddisfare la seguente condizione affinché un oggetto venga serializzato correttamente:

  1. La classe i cui oggetti sono serializzati deve implementare l'interfaccia java.io.Serializable.
  2. Tutti i campi membro della classe devono essere serializzabili. Se un particolare campo non è serializzabile, dovremmo contrassegnarlo come transitorio.

Al contrario, una classe è serializzabile solo se implementa l'interfaccia java.io.Serializable altrimenti non è serializzabile.

Come serializzare e deserializzare un oggetto in Java

Quando serializziamo un oggetto in Java, utilizziamo il metodo writeObject di objectOutputStream per scrivere l'oggetto in un file.

Per deserializzare l'oggetto in Java utilizziamo il metodo readObject () di ObjectInputStream per leggere il contenuto del file e leggerlo in un oggetto.

In questo esempio, abbiamo una classe Student che implementa l'interfaccia Serializable. Ciò significa che possiamo serializzare o deserializzare gli oggetti della classe Student.

Nel metodo principale del programma Java, creiamo un oggetto classe Student. Quindi creiamo un ObjectOutputStream che punta a un oggetto FileOutputStream che a sua volta punta a un file in cui dobbiamo scrivere l'oggetto Student. Quindi chiamiamo il metodo writeObject () che scrive l'oggetto nel file.

Dopo aver scritto con successo l'oggetto specificato nel file specificato, il programma fornisce un messaggio di output appropriato. Quindi deserializziamo l'oggetto invertendo il processo precedente. Per prima cosa creiamo un oggetto ObjectOutputStream in cui leggiamo il file il cui contenuto deve essere letto.

Quindi utilizziamo il metodo readObject () per leggere il contenuto e trasmetterlo all'oggetto Student. Quindi stampiamo il contenuto dell'oggetto Student.

Esempio di serializzazione / deserializzazione

Il seguente programma Java mostra il meccanismo di serializzazione / deserializzazione in Java come discusso sopra.

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);} } }

Produzione:

Esempio di serializzazione / deserializzazione

Si noti che dopo la deserializzazione, otteniamo lo stesso oggetto che abbiamo serializzato in precedenza quando apriamo di nuovo lo stesso file.

Parola chiave transitoria Java

Una parola chiave transiente viene utilizzata per rendere transitorio un membro di dati, ad esempio non vogliamo serializzarlo.

Per esempio, considera la seguente classe Employee. Qui abbiamo il campo ID dipendente insieme agli altri campi. Ora, se decidiamo che il campo Employee Id non deve essere serializzato, lo dichiariamo 'transitorio'.

Di seguito viene fornito un esempio di programma 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);} } }

Produzione:

Parola chiave transitoria Java

Nel programma precedente, abbiamo serializzato l'oggetto Employee. Si noti tuttavia che il campo ID dipendente della classe Employee è dichiarato 'transitorio'. Ora per verificare la serializzazione, deserializziamo l'oggetto. L'output mostra l'oggetto Employee come '0 Eddie'. Ciò significa che l'ID dipendente non è stato salvato nel file.

Java.io.NotSerializableException in Java

L'eccezione di java.io.NotSerializableException è un'eccezione generata quando la classe non è idonea per la serializzazione. La classe che non implementa l'interfaccia Serializable diventa non idonea per la serializzazione.

Il seguente programma Java dimostra 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);} } }

Produzione:

Java.io.NotSerializableException in Java

Come visto dal programma precedente, la classe Employee non implementa l'interfaccia Serializable. Quindi, quando proviamo a serializzare l'oggetto della classe Employee, viene generata NotSerializableException.

Interfaccia clonabile in Java

Clonare oggetti significa fare una copia degli oggetti. Java supporta la clonazione di oggetti utilizzando il ' Clonabile 'Interfaccia. L'interfaccia clonabile è un'interfaccia marker ed è una parte del pacchetto java.lang.

Quando una classe implementa l'interfaccia Cloneable, implica che possiamo clonare gli oggetti di questa classe. La classe Object di Java contiene il ' clone ()' metodo. Quindi l'interfaccia clonabile implementata da una particolare classe autorizza il metodo clone () a creare copie di istanze di classe.

Se una classe non implementa un'interfaccia clonabile e richiama comunque il metodo clone (), l'eccezione CloneNotSupportedException viene lanciato dal compilatore Java.

Le classi che implementano l'interfaccia Cloneable dovrebbero sovrascrivere il metodo clone ().

Allora, cos'è la clonazione di oggetti?

La clonazione di oggetti è un processo mediante il quale creiamo una copia esatta dell'oggetto utilizzando il metodo clone () della classe Object. Affinché il metodo clone () possa essere sovrascritto e richiamato, la classe deve implementare l'interfaccia Cloneable.

La sintassi generale del metodo clone () è fornita di seguito:

protetto Oggetto clone () lanci CloneNotSupportedException

Il metodo clone () crea una copia esatta dell'oggetto con un tempo di elaborazione inferiore a quello impiegato per creare un nuovo oggetto utilizzando la nuova parola chiave.

Il seguente programma Java dimostra l'uso del metodo clone () e dell'interfaccia 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){} } }

Produzione:

Clonazione di oggetti

In questo programma, abbiamo una classe Student che implementa l'interfaccia Clonabile. Inoltre sovrascrive il metodo clone () chiamando il metodo super.clone (). Nel metodo principale creiamo un nuovo oggetto Student e quindi chiamiamo il metodo clone () su questo oggetto che restituisce il nuovo oggetto Student.

Clone array in Java

Abbiamo esplorato la clonazione degli array nel nostro tutorial sugli array. Poiché gli array Java implementano l'interfaccia Cloneable per impostazione predefinita, non è necessario implementarli esplicitamente. Quando l'array unidimensionale viene clonato, viene generata una copia completa dell'array. Quando viene clonato un array bidimensionale, viene eseguita una copia superficiale.

Fare una copia superficiale è il comportamento predefinito del metodo clone () in Java. Ma la maggior parte delle volte desideriamo una clonazione profonda. Nella clonazione profonda, creiamo una copia del membro dell'oggetto per membro e creiamo un clone che è indipendente dall'oggetto originale. Eventuali modifiche quindi apportate all'oggetto clone non si rifletteranno nell'oggetto originale.

Il seguente programma Java mostra la clonazione di un array unidimensionale.

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

Produzione:

Clone Array in Java

Elenco clone in Java

Il programma seguente mostra come utilizzare un metodo clone () per clonare un elenco in 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); } }

Produzione:

Elenco cloni in Java

Nel programma sopra, vediamo che abbiamo creato una classe MyList che implementa l'interfaccia Cloneable e all'interno di questa classe, sovrascriviamo il metodo clone () che ci aiuta a clonare List. Nel metodo principale, creiamo un elenco di elementi e poi cloniamo ogni elemento dell'elenco iterando sull'elenco.

Domande frequenti

D # 1) Qual è l'uso di Marker Interface in Java?

Risposta: L'interfaccia marker, nota anche come 'interfaccia con tag', contrassegna la classe e informa il compilatore che questa classe può implementare un comportamento speciale.

D # 2) Cosa sono tutte le interfacce Marker in Java?

Risposta: Serializable, Cloneable e Remote sono le interfacce che sono gli esempi di interfacce marker in Java.

D # 3) Perché è serializzabile un'interfaccia Marker?

Risposta: L'interfaccia serializzabile non ha metodi o variabili membro. È un'interfaccia vuota che la classifica come Marker Interface.

D # 4) È eseguibile un'interfaccia Marker?

Risposta: No, eseguibile non è un'interfaccia marker. L'interfaccia eseguibile non è vuota e fornisce una dichiarazione del metodo run () al suo interno.

D # 5) Perché dobbiamo implementare un'interfaccia clonabile?

Risposta: Implementando un'interfaccia clonabile per una classe, indichiamo che gli oggetti di questa classe possono essere clonati utilizzando il metodo clone () della classe Object. Se una classe che utilizza il metodo clone () non implementa un'interfaccia clonabile, viene generata l'eccezione 'CloneNotSupportedException'.

Conclusione

Con questo tutorial, abbiamo completato la nostra discussione sulle interfacce in Java. Abbiamo discusso il concetto di interfacce, la loro struttura, definizione, utilizzo, ecc. Abbiamo anche discusso alcune delle interfacce importanti nelle interfacce Comparable, Comparator, Marker, ecc.

In questo tutorial, abbiamo discusso due esempi di interfacce marker, ovvero serializzabili e clonabili. Un'interfaccia serializzabile viene utilizzata per rendere persistente un oggetto. L'interfaccia clonabile viene utilizzata per clonare gli oggetti della classe. Entrambe queste interfacce sono interfacce marker, ovvero sono vuote.

Ma quando una classe li implementa, indica che il compilatore può aspettarsi un comportamento speciale dalle classi che li implementano.

Per esempio, quando una classe implementa un'interfaccia Serializable, possiamo serializzare o deserializzare gli oggetti della classe e salvare / recuperare il loro stato.

Una classe che implementa un'interfaccia clonabile indica che possiamo clonare gli oggetti di questa classe. L'implementazione predefinita del metodo clone () crea una copia superficiale dell'oggetto mentre possiamo sovrascrivere il metodo clone () per creare una copia completa.

=> Esplora la serie completa di formazione Java qui

Lettura consigliata

^