marker interface java
Denne opplæringen forklarer hva som er et markørgrensesnitt i Java. Det dekker også Serialization Deserialization and Cloning in Java med kodeeksempler:
Vi vil diskutere det siste emnet under grensesnitt, dvs. markørgrensesnitt i Java.
Når vi er ferdige med markørgrensesnittet, vil vi diskutere to eksempler, dvs. serialiserbart og klonbart grensesnitt i Java. La oss begynne med Marker-grensesnittet.
=> Besøk her for å lære Java fra bunnen av
Hva du vil lære:
- Markørgrensesnitt i Java
- Serialisering i Java
- Java Serializable Interface
- Klonabelt grensesnitt i Java
- Konklusjon
Markørgrensesnitt i Java
Et markørgrensesnitt i Java er et tomt grensesnitt som ikke har noen felt eller metoder. Dette markørgrensesnittet forteller kompilatoren at objektene i klassen som implementerer markørgrensesnittet er forskjellige, og at de skal behandles annerledes.
Hvert markørgrensesnitt i Java indikerer at det representerer noe spesielt for JVM eller kompilator.
I Java har vi tre grensesnitt som er markørgrensesnitt som vist nedenfor:
# 1) Serialiserbart grensesnitt: Serializable er et markørgrensesnitt som er tilstede i java.io-pakken. Vi kan serieisere objekter ved hjelp av dette grensesnittet, dvs. lagre objekttilstanden i en fil.
# 2) Klonabelt grensesnitt: Det klonbare grensesnittet er en del av java.lang-pakken og lar objektene klones.
# 3) Eksternt grensesnitt: Det eksterne grensesnittet er en del av java.RMI-pakken, og vi bruker dette grensesnittet til å lage RMI-applikasjoner. Dette grensesnittet håndterer hovedsakelig eksterne objekter.
I denne opplæringen vil vi diskutere det serieiserbare og klonable grensesnittet. Det eksterne grensesnittet vil bli diskutert når vi flytter til RMI i Java.
Serialisering i Java
Før vi går inn i detaljene i Serializable-grensesnittet i Java, la oss forstå prosessen med serialisering så vel som deserialisering i Java.
Serialisering kan defineres som en prosess der vi konverterer objekttilstanden til den tilsvarende byte-strømmen for å lagre objektet i minnet i en fil eller fortsette objektet.
Når vi ønsker å hente gjenstanden fra den lagrede tilstanden og få tilgang til innholdet, må vi konvertere byte-strømmen tilbake til selve Java-objektet, og denne prosessen kalles deserialisering.
På denne måten kan det være mange tilfeller der vi trenger å serialisere / deserialisere Java-objekter i løpet av en Java-applikasjon.
Prosessen med serialisering / deserialisering er vist nedenfor:
Som vist ovenfor konverterer serialisering objektet til en strøm. Deserialisering konverterer byte-strømmen tilbake til et Java-objekt.
Hele mekanismen for serialisering og deserialisering er plattformuavhengig. Dette betyr at vi kan serieisere objektet på en plattform og deretter deserialisere det på en annen plattform.
Når vi sier at vi har seriellisert Java-objektet, betyr det at vi har kalt ObjectOutputStream-metoden writeObject () for å skrive objektet til en fil.
beste mobiltelefon spyware for iphone
public final void writeObect (Object obj) kaster IOException
På samme måte, i tilfelle deserialisering, kaller vi ObjectInputStream :: readObject () -metoden for å lese dataene fra filen som har lagret objektet.
public final Object readObject () kaster IOException, ClassNotFoundException
Java Serializable Interface
Java tilbyr grensesnittet som heter 'serialiserbart' ved hjelp av hvilket vi kan implementere serialisering og deserialisering i Java.
Serialiserbart grensesnitt er en del av java.io-pakken. Det er et eksempel på et markørgrensesnitt vi diskuterte ovenfor og0 som ikke har noen metoder eller medlemmer. Det serierbare grensesnittet 'markerer' Java-klassene slik at objektene til disse klassene får muligheten til å vedvare seg selv.
Så klassen hvis objekt vi trenger å fortsette, bør implementere Serializable-grensesnittet. Da vil objektet til denne klassen (implementering av Serializable interface) bruke henholdsvis writeObject () og readObject () -metoder for å serialisere og deserialisere klasseobjektet.
Vær oppmerksom på at alle wrapper-klassene og String-klassen implementerer java.io.Serializable som standard.
Vi bør oppfylle følgende vilkår for at et objekt skal serieiseres:
- Klassen hvis objekter er seriellisert må implementere java.io.Serialiserbart grensesnitt.
- Alle medlemsfeltene i klassen må serienummereres. Hvis et bestemt felt ikke kan serienummeres, bør vi merke det som forbigående.
Omvendt kan en klasse bare serialiseres hvis den implementerer java.io.Serialiserbart grensesnitt, ellers kan den ikke serialiseres.
Hvordan serialisere og deserialisere et objekt i Java
Når vi serialiserer et objekt i Java, bruker vi objectOutputStreams writeObject-metode for å skrive objektet til en fil.
For å deserialisere objektet i Java bruker vi ObjectInputStream’s readObject () -metoden til å lese innholdet i filen og lese dem inn i et objekt.
I dette eksemplet, vi har en studentklasse som implementerer Serializable-grensesnittet. Dette betyr at vi kan serieisere eller deserialisere objektene til studentklassen.
I hovedmetoden til Java-programmet oppretter vi et studentklasseobjekt. Deretter lager vi et ObjectOutputStream som peker på et FileOutputStream-objekt som igjen peker på en fil der vi trenger å skrive Student-objektet. Deretter kaller vi metoden writeObject () som skriver objektet til filen.
Når du har skrevet det spesifiserte objektet til den angitte filen, gir programmet en passende utgangsmelding. Vi avserialiserer deretter objektet ved å reversere prosessen ovenfor. Først oppretter vi et ObjectOutputStream-objekt der vi leser filen hvis innhold skal leses.
Vi bruker deretter metoden readObject () til å lese innholdet og kaste det til studentobjektet. Deretter skriver vi ut innholdet på Student-objektet.
Eksempel på serialisering / deserialisering
Følgende Java-program viser serialiserings- / deserialiseringsmekanismen i Java som diskutert ovenfor.
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);} } }
Produksjon:
Merk at etter deserialisering får vi det samme objektet som vi har seriellisert tidligere når vi åpner den samme filen igjen.
Java Transient Keyword
Et forbigående nøkkelord brukes til å gjøre et datamedlem forbigående, dvs. vi vil ikke serieisere det.
For eksempel, vurdere følgende klasse Ansatt. Her har vi ansatt-ID-feltet sammen med de andre feltene. Nå hvis vi bestemmer at ansatt-ID-feltet ikke skal serieiseres, erklærer vi det som 'forbigående'.
Et eksempel på Java-program er gitt nedenfor.
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);} } }
Produksjon:
I programmet ovenfor har vi serie ansatt-objektet. Men merk deg at ansatt-id-feltet i medarbeiderklassen blir erklært 'forbigående'. Nå for å sjekke serieiseringen avserialiserer vi objektet. Utgangen viser medarbeiderobjektet som '0 Eddie'. Dette betyr at ansatt-ID ikke ble lagret i filen.
Java.io.NotSerializableException I Java
Unntaket fra java.io.NotSerializableException er et unntak som kastes når klassen ikke er kvalifisert for serialisering. Klassen som ikke implementerer Serializable-grensesnittet, blir ikke kvalifisert for serialisering.
Java-programmet nedenfor viser 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);} } }
Produksjon:
Som det fremgår av ovennevnte program, implementerer ikke medarbeiderklassen Serializable-grensesnittet. Derfor, når vi prøver å serieisere objektet for ansattklassen, kastes NotSerializableException.
Klonabelt grensesnitt i Java
Kloning av objekter betyr å lage en kopi av gjenstandene. Java støtter objektkloning ved å bruke “ Klonbar ”Grensesnitt. Det klonbare grensesnittet er et markørgrensesnitt og er en del av pakken java.lang.
Når en klasse implementerer det klonable grensesnittet, innebærer det at vi kan klone objektene til denne klassen. Objektklassen til Java inneholder ' klone () ’Metode. Så klonabelt grensesnitt implementert av en bestemt klasse autoriserer klone () -metoden til å lage kopier av klasseinstanser.
Hvis en klasse ikke implementerer et klonabelt grensesnitt og fremdeles påkaller clone () -metoden, er unntaket CloneNotSupportedException blir kastet av Java-kompilatoren.
Klasser som implementerer Cloneable-grensesnittet, bør overstyre clone () -metoden.
Så hva er objektkloning?
Objektkloning er en prosess der vi lager en nøyaktig kopi av objektet ved hjelp av klon () -metoden i Object-klassen. For at klonemetoden () skal overstyres og påberopes, må klassen implementere det klonable grensesnittet.
Den generelle syntaksen for clone () -metoden er gitt nedenfor:
beskyttet Objektklon () kaster CloneNotSupportedException
Metoden clone () lager en nøyaktig kopi av objektet med mindre behandlingstid enn det som er tatt for å opprette et nytt objekt ved hjelp av det nye nøkkelordet.
Java-programmet nedenfor viser bruken av clone () -metoden og Cloneable-grensesnittet.
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){} } }
Produksjon:
I dette programmet har vi en studentklasse som implementerer Cloneable-grensesnittet. Det overstyrer også clone () -metoden ved å ringe super.clone () -metoden. I hovedmetoden oppretter vi et nytt studentobjekt og kaller deretter klonemetoden () på dette objektet som returnerer det nye studentobjektet.
Clone Array In Java
Vi utforsket kloning av matriser i veiledningen vår om Arrays. Siden Java-arrays implementerer Cloneable interface som standard, trenger de ikke å implementeres eksplisitt. Når den endimensjonale matrisen er klonet, genereres en dyp kopi av matrisen. Når en todimensjonal matrise blir klonet, blir det laget en grunne kopi.
Å lage en grunne kopi er standardoppførselen til clone () -metoden i Java. Men mesteparten av tiden ønsker vi dyp kloning. I dyp kloning lager vi en kopi av objektmedlemmet etter medlem og lager en klon som er uavhengig av det opprinnelige objektet. Eventuelle endringer som da er gjort på kloneobjektet, reflekteres ikke i det opprinnelige objektet.
Følgende Java-program viser kloning av en endimensjonal matrise.
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 Produksjon:

Kloneliste i Java
Programmet nedenfor viser hvordan du bruker en klon () -metode til å klone en liste i 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); } }
Produksjon:

I programmet ovenfor ser vi at vi har opprettet en MyList-klasse som implementerer Cloneable-grensesnittet, og inne i denne klassen overstyrer vi klon () -metoden som hjelper oss å klone listen. I hovedmetoden oppretter vi en liste over elementer og kloner deretter hvert element i listen ved å itere over listen.
ofte stilte spørsmål
Q # 1) Hva er bruken av Marker Interface i Java?
Svar: Markørgrensesnitt som også er kjent som 'merket grensesnitt' merker klassen og informerer kompilatoren om at denne klassen kan implementere en spesiell oppførsel.
Q # 2) Hva er alle markørgrensesnittene i Java?
Svar: Serializable, Cloneable og Remote er grensesnittene som er eksemplene på markørgrensesnitt i Java.
Spørsmål 3) Hvorfor kan serienummereres et markørgrensesnitt?
Svar: Serialiserbart grensesnitt har ingen metoder eller medlemsvariabler. Det er et tomt grensesnitt som klassifiserer det som et markørgrensesnitt.
Q # 4) Kan kjøres et markørgrensesnitt?
Svar: Nei, kjørbar er ikke et markørgrensesnitt. Det kjørbare grensesnittet er ikke tomt, og det gir en kjøredeklarasjonsmetode () i det.
Spørsmål nr. 5) Hvorfor trenger vi å implementere et klonabelt grensesnitt?
Svar: Ved å implementere et klonbart grensesnitt for en klasse, indikerer vi at objektene i denne klassen kan klones ved hjelp av klon () -metoden i Object-klassen. Hvis en klasse som bruker klon () -metoden ikke implementerer et klonabelt grensesnitt, kastes unntaket 'CloneNotSupportedException'.
Konklusjon
Med denne veiledningen har vi fullført vår diskusjon om grensesnitt i Java. Vi har diskutert begrepet grensesnitt, deres struktur, definisjon, bruk osv. Vi har også diskutert noen av de viktige grensesnittene i Java-lignende Comparable, Comparator, Marker-grensesnitt, etc.
I denne opplæringen diskuterte vi to eksempler på markørgrensesnitt, dvs. seriell og klonbar. Et serielliserbart grensesnitt brukes til å vedvare et objekt. Det klonbare grensesnittet brukes til å klone klasseobjektene. Begge disse grensesnittene er markørgrensesnitt, dvs. de er tomme.
Men når en klasse implementerer dem, indikerer de at kompilatoren kan forvente spesiell oppførsel fra klassene som implementerer dem.
For eksempel, når en klasse implementerer et serialiserbart grensesnitt, kan vi serieisere eller deserialisere klasseobjektene og lagre / hente statusen deres.
En klasse som implementerer et klonabelt grensesnitt indikerer at vi kan klone objektene i denne klassen. Standardimplementeringen av clone () -metoden skaper en grunne kopi av objektet mens vi kan overstyre clone () -metoden for å lage en dyp kopi.
=> Utforsk Complete Java Training Series her
Anbefalt lesing
- Sett grensesnitt i Java: Java Set Tutorial med eksempler
- ListIterator-grensesnitt i Java med eksempler
- Java-distribusjon: Opprettelse og utføring av Java JAR-fil
- Og Java - og dens implementering og definisjoner
- Java Basics: Java Syntax, Java Class og Core Java Concepts
- Java Class Vs Object - Hvordan bruke klasse og objekt i Java
- Java Virtual Machine: Hvordan JVM hjelper med å kjøre Java-applikasjoner
- Sammenlignbare og komparatorgrensesnitt i Java