marker interface java
Denne vejledning forklarer, hvad der er en markørgrænseflade i Java. Det dækker også Serialization Deserialization and Cloning in Java med kodeeksempler:
Vi vil diskutere det sidste emne under grænseflader, dvs. markørgrænseflade i Java.
Når vi er færdige med markørgrænsefladen, diskuterer vi to eksempler, dvs. seriel og klonbar grænseflade i Java. Lad os begynde med Marker-grænsefladen.
=> Besøg her for at lære Java fra bunden
Hvad du vil lære:
- Markørinterface i Java
- Serialisering i Java
- Java Serializable Interface
- Klonbar grænseflade i Java
- Konklusion
Markørinterface i Java
En markørgrænseflade i Java er en tom grænseflade, der ikke har nogen felter eller metoder. Denne markørgrænseflade fortæller kompilatoren, at objekterne i klassen, der implementerer markørgrænsefladen, er forskellige, og at de skal behandles forskelligt.
Hver markørgrænseflade i Java indikerer, at den repræsenterer noget specielt for JVM eller compiler.
I Java har vi tre grænseflader, der er markørgrænseflader som vist nedenfor:
# 1) Serialiserbar grænseflade: Serializable er en markørgrænseflade, der findes i java.io-pakken. Vi kan serieisere objekter ved hjælp af denne grænseflade, dvs. gemme objekttilstanden i en fil.
# 2) Klonbar grænseflade: Den klonbare grænseflade er en del af pakken java.lang og gør det muligt at klone objekterne.
# 3) Fjernbetjening: Fjerninterfacet er en del af java.RMI-pakken, og vi bruger denne grænseflade til at oprette RMI-applikationer. Denne grænseflade beskæftiger sig primært med eksterne objekter.
I denne vejledning vil vi diskutere den serielle og klonbare grænseflade. Fjerninterfacet vil blive diskuteret, når vi flytter til RMI i Java.
Serialisering i Java
Før vi går ind i detaljerne i Serializable-grænsefladen i Java, lad os forstå processen med serialisering såvel som deserialisering i Java.
Serialisering kan defineres som en proces, hvorved vi konverterer objekttilstanden til dens ækvivalente byte-strøm for at gemme objektet i hukommelsen i en fil eller vedvarer genstanden.
Når vi vil hente objektet fra dets gemte tilstand og få adgang til dets indhold, bliver vi nødt til at konvertere byte-strømmen tilbage til det aktuelle Java-objekt, og denne proces kaldes deserialisering.
På denne måde kan der være mange tilfælde, hvor vi har brug for at serialisere / deserialisere Java-objekter i en levetid på Java-applikationen.
Processen med serialisering / deserialisering er vist nedenfor:
Som vist ovenfor konverterer serialisering objektet til en stream. Deserialisering konverterer byte-strømmen tilbage til et Java-objekt.
Hele mekanismen til serialisering og deserialisering er platformuafhængig. Dette betyder, at vi kan serieisere objektet på en platform og derefter deserialisere det på en anden platform.
Når vi siger, at vi har serialiseret Java-objektet, betyder det, at vi har kaldt ObjectOutputStream-metoden writeObject () for at skrive objektet til en fil.
Jeg har brug for en falsk e-mail-adresse
offentlig endelig ugyldig writeObect (Objekt obj) kaster IOException
På samme måde kalder vi i tilfælde af deserialisering ObjectInputStream :: readObject () -metoden for at læse dataene fra den fil, der har gemt objektet.
offentlig endelig Objekt readObject () kaster IOException, ClassNotFoundException
Java Serializable Interface
Java leverer grænsefladen med navnet 'serialiserbar' ved hjælp af hvilken vi kan implementere serialisering og deserialisering i Java.
Serialiserbar grænseflade er en del af java.io-pakken. Det er et eksempel på en markørgrænseflade, vi diskuterede ovenfor og0, der ikke har nogen metoder eller medlemmer. Den serieliserbare grænseflade 'markerer' Java-klasser, så objekterne i disse klasser får evnen til at vedvare sig selv.
Så klassen, hvis objekt vi har brug for, skal implementere Serializable-grænsefladen. Derefter bruger objektet i denne klasse (implementering af Serializable interface) henholdsvis writeObject () og readObject () til serialisering og deserialisering af klasseobjektet.
Bemærk, at alle indpakningsklasser og klasse String implementerer java.io.Serializable som standard.
Vi skal opfylde følgende betingelse for, at et objekt kan serieiseres med succes:
- Den klasse, hvis objekter er serieliseret, skal implementere java.io.Serialiserbar grænseflade.
- Alle medlemsfelter i klassen skal kunne serienummereres. Hvis et bestemt felt ikke kan serienummeres, skal vi markere det som forbigående.
Omvendt kan en klasse kun serialiseres, hvis den implementerer java.io.Serialiserbar grænseflade, ellers kan den ikke serialiseres.
Sådan serialiseres og deserialiseres et objekt i Java
Når vi serieliserer et objekt i Java, bruger vi objectOutputStream's writeObject-metode til at skrive objektet til en fil.
Til deserialisering af objektet i Java bruger vi ObjectInputStream's readObject () metode til at læse indholdet af filen og læse dem ind i et objekt.
I dette eksempel vi har en elevklasse, der implementerer Serializable-grænsefladen. Dette betyder, at vi kan serieisere eller deserialisere objekterne i studenterklassen.
I Java-programmets hovedmetode opretter vi et elevklasseobjekt. Derefter opretter vi et ObjectOutputStream, der peger på et FileOutputStream-objekt, der igen peger på en fil, hvor vi skal skrive Student-objektet. Derefter kalder vi metoden writeObject (), der skriver objektet til filen.
Ved vellykket skrivning af det specificerede objekt til den angivne fil giver programmet en passende outputbesked. Vi deserialiserer derefter objektet ved at vende ovenstående proces. Først opretter vi et ObjectOutputStream-objekt, hvor vi læser den fil, hvis indhold skal læses.
Vi bruger derefter metoden readObject () til at læse indholdet og kaste det til Student-objektet. Derefter udskriver vi indholdet af Student-objektet.
Eksempel på serialisering / deserialisering
Følgende Java-program viser serialiserings- / deserialiseringsmekanismen i Java som beskrevet 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);} } }
Produktion:
Bemærk, at efter deserialisering får vi det samme objekt, som vi har serialiseret tidligere, da vi åbner den samme fil igen.
Java Transient Keyword
Et forbigående nøgleord bruges til at gøre et datamedlem forbigående, dvs. vi vil ikke serieisere det.
For eksempel, overvej følgende klasse medarbejder. Her har vi medarbejder-id-feltet sammen med de andre felter. Hvis vi nu beslutter, at feltet Medarbejder-id ikke skal serieliseres, erklærer vi det som 'forbigående'.
Et eksempel på Java-program er angivet 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);} } }
Produktion:
I ovenstående program har vi serieret medarbejderobjektet. Men bemærk, at medarbejder-id-feltet i medarbejderklassen erklæres 'forbigående'. Nu for at kontrollere serieiseringen deserialiserer vi objektet. Outputtet viser medarbejderobjektet som '0 Eddie'. Dette betyder, at medarbejder-id'en ikke blev gemt i filen.
Java.io.NotSerializableException i Java
Undtagelsen fra java.io.NotSerializableException er en undtagelse, der kastes, når klassen ikke er berettiget til serialisering. Klassen, der ikke implementerer Serializable-grænsefladen, er ikke kvalificeret til serialisering.
Nedenstående Java-program demonstrerer 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);} } }
Produktion:
Som det ses af ovenstående program, implementerer medarbejderklassen ikke grænsefladen Serializable. Derfor, når vi forsøger at serieisere medarbejderklasseobjektet, kastes NotSerializableException.
Klonbar grænseflade i Java
Kloning af objekter betyder at lave en kopi af objekterne. Java understøtter kloning af objekter ved hjælp af “ Klonabel ”Interface. Den klonbare grænseflade er en markørgrænseflade og er en del af java.lang-pakken.
Når en klasse implementerer Cloneable-interface, betyder det, at vi kan klone objekterne i denne klasse. Objektklassen i Java indeholder ' klon () ’Metode. Så Cloneable-interface, der er implementeret af en bestemt klasse, giver klonemetoden () tilladelse til at lave kopier af klasseinstanser.
Hvis en klasse ikke implementerer en Cloneable-grænseflade og stadig påberåber sig metoden clone (), er undtagelsen CloneNotSupportedException kastes af Java-kompilatoren.
Klasser, der implementerer Cloneable-grænsefladen, bør tilsidesætte metoden clone ().
Så hvad er objektkloning?
Objektkloning er en proces, hvor vi opretter en nøjagtig kopi af objektet ved hjælp af klonen () -metoden i objektklassen. For at klon () -metoden kan tilsidesættes og påberåbes, skal klassen implementere Cloneable-grænsefladen.
Den generelle syntaks for klonmetoden () er angivet nedenfor:
beskyttet Objektklon () kaster CloneNotSupportedException
Metoden klon () opretter en nøjagtig kopi af objektet med mindre behandlingstid end den tid, det tager at oprette et nyt objekt ved hjælp af det nye nøgleord.
Nedenstående Java-program viser brugen af metoden clone () og Cloneable-grænsefladen.
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){} } }
Produktion:
I dette program har vi en elevklasse, der implementerer Cloneable-grænsefladen. Det tilsidesætter også klon () -metoden ved at kalde metoden super.clone (). I hovedmetoden opretter vi et nyt Student-objekt og kalder derefter metoden clone () på dette objekt, der returnerer det nye Student-objekt.
Klonarray i Java
Vi udforskede kloning af arrays i vores tutorial om Arrays. Da Java-arrays implementerer Cloneable-interface som standard, behøver de ikke eksplicit implementeres. Når det endimensionelle array er klonet, genereres en dyb kopi af arrayet. Når et 2-dimensionelt array er klonet, laves der en lav kopi.
At lave en lav kopi er standardadfærden for klonmetoden () i Java. Men det meste af tiden ønsker vi dyb kloning. Ved dyb kloning laver vi en kopi af objektmedlemmen efter medlem og opretter en klon, der er uafhængig af det oprindelige objekt. Eventuelle ændringer, der derefter foretages på klonobjektet, afspejles ikke i det oprindelige objekt.
Følgende Java-program viser kloning af et endimensionelt array.
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 Produktion:

Klonliste i Java
Programmet nedenfor viser, hvordan man bruger en klon () metode til at 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); } }
Produktion:

I ovenstående program ser vi, at vi har oprettet en MyList-klasse, der implementerer Cloneable-grænsefladen, og inden for denne klasse tilsidesætter vi klonmetoden (), der hjælper os med at klone listen. I hovedmetoden opretter vi en liste over elementer og kloner derefter hvert element på listen ved at gentage den over listen.
Ofte stillede spørgsmål
Q # 1) Hvad er brugen af Marker Interface i Java?
Svar: Markørinterface, der også er kendt som 'tagged interface', mærker klassen og informerer kompilatoren om, at denne klasse kan implementere en særlig adfærd.
Spørgsmål nr. 2) Hvad er alle markørinterfaces i Java?
Svar: Serializable, Cloneable og Remote er de grænseflader, der er eksemplerne på markørgrænseflader i Java.
Spørgsmål nr. 3) Hvorfor kan serienummereres som en markørgrænseflade?
Svar: Den serieliserbare grænseflade har ingen metoder eller medlemsvariabler. Det er en tom grænseflade, der klassificerer den som en markørgrænseflade.
Q # 4) Kan køres en markørgrænseflade?
Svar: Nej, kørbar er ikke en markørgrænseflade. Den kørbare grænseflade er ikke tom, og den giver en run () -metodeerklæring inde i den.
Spørgsmål nr. 5) Hvorfor skal vi implementere en klonbar grænseflade?
Svar: Ved at implementere en klonbar grænseflade til en klasse angiver vi, at objekterne i denne klasse kan klones ved hjælp af klon () -metoden i Object-klassen. Hvis en klasse, der bruger klon () -metoden, ikke implementerer en klonbar grænseflade, kastes undtagelsen 'CloneNotSupportedException'.
Konklusion
Med denne vejledning har vi afsluttet vores diskussion om grænseflader i Java. Vi har diskuteret konceptet med grænseflader, deres struktur, definition, brug osv. Vi har også diskuteret nogle af de vigtige grænseflader i Java-lignende Comparable, Comparator, Marker interfaces osv.
I denne vejledning diskuterede vi to eksempler på markørgrænseflader, dvs. seriel og klonbar. En seriel grænseflade bruges til at fastholde et objekt. Den klonbare grænseflade bruges til at klone klasseobjekterne. Begge disse grænseflader er markørgrænseflader, dvs. de er tomme.
Men når en klasse implementerer dem, angiver de, at compileren kan forvente en særlig opførsel fra de klasser, der implementerer dem.
For eksempel, når en klasse implementerer en Serializable-interface, kan vi serieisere eller deserialisere klasseobjekterne og gemme / hente deres tilstand.
En klasse, der implementerer en klonbar grænseflade, indikerer, at vi kan klone objekterne i denne klasse. Standardimplementeringen af clone () -metoden opretter en lav kopi af objektet, mens vi kan tilsidesætte clone () -metoden for at oprette en dyb kopi.
=> Udforsk Komplet Java-træningsserie her
Anbefalet læsning
- Indstil interface i Java: Java Set-tutorial med eksempler
- ListIterator-interface i Java med eksempler
- Java-implementering: Oprettelse og udførelse af Java JAR-fil
- Og Java - og dens implementering og definitioner
- Java Basics: Java Syntax, Java Class og Core Java Concepts
- Java Class Vs Object - Sådan bruges klasse og objekt i Java
- Java Virtual Machine: Hvordan JVM hjælper med at køre Java-applikationer
- Sammenlignelige og komparatorgrænseflader i Java