Menu

Markeringsinterface in Java: serialiseerbaar en kloneerbaar

  • Hoofd
  • Andere
  • Markeringsinterface in Java: serialiseerbaar en kloneerbaar

marker interface java

Probeer Ons Instrument Voor Het Oplossen Van Problemen

Deze tutorial legt uit wat een Marker Interface in Java is. Het behandelt ook Serialization Deserialization en Cloning in Java met codevoorbeelden:

We zullen het laatste onderwerp bespreken onder Interfaces, d.w.z. Marker Interface in Java.

Nadat we klaar zijn met de marker-interface, zullen we twee voorbeelden bespreken, d.w.z. serialiseerbare en cloneerbare interface in Java. Laten we beginnen met de Marker-interface.

​ Bezoek hier om Java vanaf het begin te leren

Markeerinterfaces in Java - serialiseerbaar en te klonen

Wat je leert:

Markeringsinterface in Java

Een markeringsinterface in Java is een lege interface zonder velden of methoden. Deze marker interface vertelt de compiler dat de objecten van de klasse die de marker interface implementeren verschillend zijn en dat ze anders behandeld moeten worden.

Elke markeringsinterface in Java geeft aan dat het iets speciaals vertegenwoordigt voor JVM of compiler.

In Java hebben we drie interfaces die Marker-interfaces zijn, zoals hieronder wordt weergegeven:

# 1) Serialiseerbare interface: Serializable is een marker-interface die aanwezig is in het java.io-pakket. We kunnen objecten serialiseren met behulp van deze interface, d.w.z. de objectstatus opslaan in een bestand.

# 2) Cloneable interface: De te klonen interface is een onderdeel van het java.lang-pakket en staat toe dat de objecten worden gekloond.

# 3) Externe interface: De externe interface is een onderdeel van het java.RMI-pakket en we gebruiken deze interface om RMI-applicaties te maken. Deze interface behandelt voornamelijk objecten op afstand.

In deze tutorial bespreken we de interface die kan worden geserialiseerd en gekloond. De externe interface zal worden besproken wanneer we naar RMI in Java gaan.

Serialisatie in Java

Voordat we ingaan op de details van de Serializable-interface in Java, laten we het proces van serialisatie en deserialisatie in Java begrijpen.

Serialisatie kan worden gedefinieerd als een proces waarbij we de objectstatus omzetten in zijn equivalente bytestroom om het object in het geheugen op te slaan in een bestand of volharden het object.

Als we het object uit de opgeslagen staat willen halen en toegang willen krijgen tot de inhoud, zullen we de bytestream terug moeten converteren naar het eigenlijke Java-object en dit proces wordt deserialisatie genoemd.

Op deze manier kunnen er veel gevallen zijn waarin we Java-objecten moeten serialiseren / deserialiseren tijdens een levenslange Java-applicatie.

Het proces van serialisatie / deserialisatie wordt hieronder weergegeven:

serialisatie OF deserialisatie

Zoals hierboven getoond, zet serialisatie het object om in een stream. Deserialisatie zet de bytestream terug naar een Java-object.

Het hele mechanisme van serialisatie en deserialisatie is platformonafhankelijk. Dit betekent dat we het object op het ene platform kunnen serialiseren en het vervolgens op een ander platform kunnen deserialiseren.

Als we zeggen dat we het Java-object hebben geserialiseerd, betekent dit dat we de ObjectOutputStream-methode writeObject () hebben aangeroepen om het object naar een bestand te schrijven.

vervangende streaming filmsite voor film 4k

public final void writeObect (Object obj) gooit IOException

Evenzo roepen we in het geval van deserialisatie de ObjectInputStream :: readObject () - methode aan om de gegevens te lezen uit het bestand waarin het object is opgeslagen.

public final Object readObject () gooit IOException, ClassNotFoundException

Serialiseerbare Java-interface

Java biedt de interface met de naam ‘serializable’ waarmee we serialisatie en deserialisatie in Java kunnen implementeren.

Serialiseerbare interface is een onderdeel van het java.io-pakket. Het is een voorbeeld van een markeringsinterface die we hierboven hebben besproken en 0 die geen methoden of leden heeft. De serialiseerbare interface ‘markeert’ de Java-klassen zodat de objecten van deze klassen zichzelf kunnen handhaven.

Dus de klasse waarvan we het object moeten behouden, moet de interface voor serialiseren implementeren. Vervolgens zal het object van deze klasse (implementatie van de Serializable interface) de methoden writeObject () en readObject () gebruiken voor het serialiseren en deserialiseren van het klasseobject.

Merk op dat alle wrapper-klassen en de String-klasse standaard de java.io.Serializable implementeren.

We moeten aan de volgende voorwaarde voldoen om een ​​object met succes te serialiseren:

  1. De klasse waarvan de objecten zijn geserialiseerd, moet de interface java.io.Serializable implementeren.
  2. Alle ledenvelden van de klasse moeten serialiseerbaar zijn. Als een bepaald veld niet serialiseerbaar is, moeten we het markeren als tijdelijk.

Omgekeerd kan een klasse alleen worden geserialiseerd als deze de interface java.io.Serializable implementeert, anders kan deze niet worden geserialiseerd.

Hoe een object in Java te serialiseren en deserialiseren

Wanneer we een object in Java serialiseren, gebruiken we de writeObject-methode van objectOutputStream om het object naar een bestand te schrijven.

Voor het deserialiseren van het object in Java gebruiken we de readObject () - methode van ObjectInputStream om de inhoud van het bestand te lezen en in een object te lezen.

In dit voorbeeld we hebben een studentenklasse die de interface voor serialiseren implementeert. Dit betekent dat we de objecten van de klasse Student kunnen serialiseren of deserialiseren.

In de hoofdmethode van het Java-programma maken we een Student-klasseobject. Vervolgens maken we een ObjectOutputStream die verwijst naar een FileOutputStream-object dat op zijn beurt verwijst naar een bestand waarin we het Student-object moeten schrijven. Vervolgens roepen we de methode writeObject () aan die het object naar het bestand schrijft.

Bij het succesvol schrijven van het gespecificeerde object naar het gespecificeerde bestand, geeft het programma een passend uitvoerbericht. Vervolgens deserialiseren we het object door het bovenstaande proces om te keren. Eerst maken we een ObjectOutputStream-object waarin we het bestand lezen waarvan de inhoud moet worden gelezen.

Vervolgens gebruiken we de methode readObject () om de inhoud te lezen en deze naar het Student-object te casten. Vervolgens printen we de inhoud van het Student-object.

Serialisatie / deserialisatievoorbeeld

Het volgende Java-programma toont het serialiserings- / deserialisatiemechanisme in Java zoals hierboven besproken.

​

Uitgang:

Voorbeeld van serialisering / deserialisatie

Merk op dat we na deserialisatie hetzelfde object krijgen dat we eerder hebben geserialiseerd, omdat we hetzelfde bestand opnieuw openen.

Java Transient Sleutelwoord

Een tijdelijk trefwoord wordt gebruikt om een ​​gegevenslid tijdelijk te maken, d.w.z. we willen het niet serialiseren.

Bijvoorbeeld, overweeg de volgende klasse Medewerker. Hier hebben we het veld Werknemers-ID samen met de andere velden. Als we nu besluiten dat het veld Werknemers-ID niet moet worden geserialiseerd, verklaren we het als ‘tijdelijk’.

Een voorbeeld van een Java-programma wordt hieronder gegeven.

​

Uitgang:

Java Transient Sleutelwoord

In het bovenstaande programma hebben we het Employee-object geserialiseerd. Houd er echter rekening mee dat het veld Werknemer-id van de klasse Werknemer ‘tijdelijk’ wordt verklaard. Om de serialisering te controleren, deserialiseren we het object. De uitvoer toont het Employee-object als ‘0 Eddie’. Dit betekent dat het werknemers-ID niet in het bestand is opgeslagen.

Java.io.NotSerializableException In Java

De uitzondering van java.io.NotSerializableException is een uitzondering die wordt gegenereerd wanneer de klasse niet in aanmerking komt voor serialisatie. De klasse die de interface voor serialiseren niet implementeert, komt niet in aanmerking voor serialisering.

Het onderstaande Java-programma demonstreert de NotSerializableException.

​

Uitgang:

Java.io.NotSerializableException in Java

Zoals blijkt uit het bovenstaande programma, implementeert de klasse Employee de interface voor serialiseren niet. Daarom wordt de NotSerializableException gegenereerd wanneer we proberen het klasseobject Employee te serialiseren.

Cloneable interface in Java

Het klonen van objecten betekent het maken van een kopie van de objecten. Java ondersteunt het klonen van objecten met de “ Te klonen ' koppel. De te klonen interface is een markeringsinterface en maakt deel uit van het java.lang-pakket.

Wanneer een klasse de Cloneable-interface implementeert, betekent dit dat we de objecten van deze klasse kunnen klonen. De Object-klasse van Java bevat de ‘ kloon () ’Methode. Dus Cloneable interface geïmplementeerd door een bepaalde klasse autoriseert de clone () methode om kopieën te maken van klasse instances.

Als een klasse geen Cloneable-interface implementeert en toch de methode clone () aanroept, dan is de uitzondering CloneNotSupportedException wordt gegenereerd door de Java-compiler.

Klassen die de Cloneable-interface implementeren, zouden de clone () -methode moeten overschrijven.

Dus wat is het klonen van objecten?

Het klonen van objecten is een proces waarbij we een exacte kopie van het object maken met behulp van de methode clone () van de klasse Object. Om de methode clone () te overschrijven en aan te roepen, moet de klasse de interface Cloneable implementeren.

De algemene syntaxis van de methode clone () wordt hieronder gegeven:

beschermd Object kloon () gooit CloneNotSupportedException

De methode clone () maakt een exacte kopie van het object met minder verwerkingstijd dan die nodig is voor het maken van een nieuw object met het nieuwe trefwoord.

Het onderstaande Java-programma demonstreert het gebruik van de clone () -methode en de Cloneable-interface.

​

Uitgang:

Object klonen

In dit programma hebben we een studentenklasse die de Cloneable-interface implementeert. Het overschrijft ook de methode clone () door de methode super.clone () aan te roepen. In de hoofdmethode maken we een nieuw Student-object en roepen vervolgens de methode clone () op dit object aan die het nieuwe Student-object retourneert.

Clone Array in Java

We hebben het klonen van arrays onderzocht in onze tutorial over arrays. Aangezien Java-arrays de Cloneable-interface standaard implementeren, hoeven ze niet expliciet te worden geïmplementeerd. Wanneer de eendimensionale array wordt gekloond, wordt een diepe kopie van de array gegenereerd. Wanneer een tweedimensionale array wordt gekloond, wordt een ondiepe kopie gemaakt.

Een ondiepe kopie maken is het standaardgedrag van de methode clone () in Java. Maar meestal willen we diepgaand klonen. Bij diep klonen maken we een kopie van het object lid voor lid en maken we een kloon die onafhankelijk is van het oorspronkelijke object. Eventuele wijzigingen die vervolgens aan het kloonobject worden aangebracht, worden niet weerspiegeld in het oorspronkelijke object.

Het volgende Java-programma toont het klonen van een eendimensionale array.

​

Uitgang:

Clone Array in Java

Kloonlijst in Java

Het onderstaande programma laat zien hoe je een clone () -methode kunt gebruiken om een ​​lijst in Java te klonen.

​

Uitgang:

Kloonlijst in Java

In het bovenstaande programma zien we dat we een MyList-klasse hebben gemaakt die de Cloneable-interface implementeert en binnen deze klasse overschrijven we de clone () -methode die ons helpt de List te klonen. In de hoofdmethode maken we een lijst met elementen en klonen we vervolgens elk element van de lijst door de lijst te herhalen.

Veel Gestelde Vragen

V # 1) Wat is het gebruik van Marker Interface in Java?

Antwoord: Marker-interface die ook bekend staat als ‘tagged interface’ tagt de klasse en informeert de compiler dat deze klasse een speciaal gedrag kan implementeren.

Vraag 2) Wat zijn alle markeringsinterfaces in Java?

Antwoord: Serializable, Cloneable en Remote zijn de interfaces die de voorbeelden zijn van markerinterfaces in Java.

V # 3) Waarom kan een markeringsinterface worden geserialiseerd?

Antwoord: De serialiseerbare interface heeft geen methoden of lidvariabelen. Het is een lege interface die het classificeert als een markeringsinterface.

V # 4) Kan een Marker Interface worden uitgevoerd?

Antwoord: Nee, runnable is geen markeringsinterface. De uitvoerbare interface is niet leeg en bevat een run () methode-declaratie erin.

V # 5) Waarom moeten we een Cloneable-interface implementeren?

Antwoord: Door een kloneerbare interface voor een klasse te implementeren, geven we aan dat de objecten van deze klasse kunnen worden gekloond met de methode clone () van de klasse Object. Als een klasse die de methode clone () gebruikt geen interface implementeert die kan worden gekloond, wordt de uitzondering ‘CloneNotSupportedException’ gegenereerd.

Gevolgtrekking

Met deze tutorial hebben we onze discussie over interfaces in Java afgerond. We hebben het concept van interfaces, hun structuur, definitie, gebruik, etc. besproken. We hebben ook enkele van de belangrijke interfaces in Java-achtige Comparable, Comparator, Marker interfaces, etc. besproken.

In deze tutorial hebben we twee voorbeelden van markerinterfaces besproken, d.w.z. serialiseerbaar en kloneerbaar. Een serialiseerbare interface wordt gebruikt om een ​​object te behouden. De kloonbare interface wordt gebruikt om de klasseobjecten te klonen. Beide interfaces zijn markeringsinterfaces, d.w.z. ze zijn leeg.

Maar wanneer een klasse ze implementeert, geven ze aan dat de compiler een speciaal gedrag kan verwachten van de klassen die ze implementeren.

Bijvoorbeeld, wanneer een klasse een serialiseerbare interface implementeert, kunnen we de klasseobjecten serialiseren of deserialiseren en hun status opslaan / ophalen.

Een klasse die een kloonbare interface implementeert, geeft aan dat we de objecten van deze klasse kunnen klonen. De standaardimplementatie van de methode clone () maakt een ondiepe kopie van het object, terwijl we de methode clone () kunnen overschrijven om een ​​diepe kopie te maken.

​ Ontdek hier de complete Java-trainingsserie

Aanbevolen literatuur

^