Serialisatie. Het begin.

'U weet nog dat we vandaag onderzoek hebben gedaan naar het opslaan van objecten in en het lezen ervan uit een bestand?'

"Ja, we hebben zojuist opgeslagen in een uitvoerstroom, een leesbewerking van een invoerstroom."

"Goed gedaan, Amigo. Het is goed om te horen dat je deze details opmerkt. Zou je de code kunnen voltooien zodat deze kan worden opgeslagen in en gelezen uit een bestand?"

"Wat voltooien?! Declareer een FileInputStream en FileOutputStream en geef ze door aan de opslag- en laadmethoden. Er is hier niets te verwarren. Supereenvoudig."

"Ik ben blij voor je. Nu een nieuw onderwerp: serialisatie ."

Serialisatie is bijna hetzelfde als wat we net deden, maar veel cooler en ingebouwd in de Java-machine. De Java-machine kan zijn objecten opslaan en laden. Het heeft niet eens de opslag- en laadmethoden nodig om het te doen: alle objecten worden opgeslagen in de Java-machine en het heeft er volledige toegang toe."

We nemen gewoon het object en slaan het op in een stream en lezen van een stream:

public static void main(String[] args) throws Exception
{
 Cat cat = new Cat();

 //Save a cat to file
 FileOutputStream fileOutput = new FileOutputStream("cat.dat");
 ObjectOutputStream outputStream = new ObjectOutputStream(fileOutput);
 outputStream.writeObject(cat);
 fileOutput.close();
 outputStream.close();

 //Load a cat from file
 FileInputStream fiStream = new FileInputStream("cat.dat");
 ObjectInputStream objectStream = new ObjectInputStream(fiStream);
 Object object = objectStream.readObject();
 fiStream.close();
 objectStream.close();

 Cat newCat = (Cat)object;
}

"Dat is het?"

"Precies. Er is een zeer groot en complex serialisatiemechanisme waarmee we kunnen opslaan in een stream en kunnen lezen uit een stream van bijna elk gegevenstype."

'Bijna alle. Dus geen gegevenstype?'

"Ja, feit is dat niet alle objecten de inherente mogelijkheid hebben om te worden opgeslagen . Sommige objecten slaan niet al hun gegevens intern op. In plaats daarvan verwijzen ze alleen naar andere objecten en/of gegevensbronnen. Bijvoorbeeld, de console (System. in), een invoerstroom (InputStream) en andere dingen."

Daarom bedachten de makers van Java de speciale Serializable interface marker . Het wordt een marker genoemd , omdat het geen gegevens en methoden bevat. Het wordt alleen gebruikt om klassen te "taggen" of te "markeren". Als we denken dat onze klasse al zijn gegevens intern opslaat, kunnen we deze markeren met implementeert Serializable .

Hier is een «cat» voorbeeld met ondersteuning voor serialisatie:

class Cat implements Serializable
{
 public String name;
 public int age;
 public int weight;
}

Wanneer we een object proberen te serialiseren (opslaan), controleert de Java-machine of het serialisatie ondersteunt: implementeert het de Serializable-interface? Als dit het geval is, wordt het object opgeslagen. Zo niet, dan genereert het een uitzondering om aan te geven dat serialisatie onmogelijk is.
Hier moet u begrijpen dat een serialiseerbaar object alleen uit serialiseerbare objecten mag bestaan.

'Nou, dat is logisch. Je kunt het geheel niet redden zonder de delen ervan te redden.'

"Precies."

"En hoe zit het met ints, Strings en ArrayLists?"

"Ze ondersteunen allemaal serialisatie. De makers van Java hebben er speciaal voor gezorgd dat dit gebeurde. Er zouden hier geen problemen moeten zijn."

Bovendien wordt het type van een object opgeslagen wanneer het object wordt geserialiseerd. U kunt nu een verwijzing naar een Cat-object opslaan in een objectvariabele. Alles zal prima serialiseren en deserialiseren.

"Deserialiseren?"

" Deserialisatie is het proces van het omkeren van serialisatie: het lezen en reconstrueren van een object uit een stream/bestand."

"Ah, geen vragen meer dan."