జావాలో సీరియలైజేషన్ మరియు డీరియలైజేషన్ మధ్య తేడా ఏమిటి?

హాయ్! నేటి పాఠంలో, మేము జావాలో సీరియలైజేషన్ మరియు డీరియలైజేషన్ గురించి మాట్లాడుతాము. మేము ఒక సాధారణ ఉదాహరణతో ప్రారంభిస్తాము. మీరు కంప్యూటర్ గేమ్‌ని సృష్టించారని అనుకుందాం. మీరు 90వ దశకంలో పెరిగి, ఆ యుగానికి చెందిన గేమ్ కన్సోల్‌లను గుర్తుంచుకుంటే, ఈ రోజు మనం పెద్దగా భావించే వాటిలో ఏదో ఒకటి లేదని మీకు తెలిసి ఉండవచ్చు — గేమ్‌లను సేవ్ చేయడం మరియు లోడ్ చేయగల సామర్థ్యం :) కాకపోతే, ఊహించుకోండి! ఈ సామర్థ్యాలు లేని ఆట ఈ రోజు నాశనమవుతుందని నేను భయపడుతున్నాను! ఏమైనప్పటికీ ఆటను "సేవ్" మరియు "లోడ్" చేయడం అంటే ఏమిటి? సరే, మేము సాధారణ అర్థాన్ని అర్థం చేసుకున్నాము: మేము ఆటను ఆపివేసిన ప్రదేశం నుండి కొనసాగించాలనుకుంటున్నాము. దీన్ని చేయడానికి, మేము ఒక రకమైన "చెక్ పాయింట్"ని సృష్టిస్తాము, దానిని మేము ఆటను లోడ్ చేయడానికి ఉపయోగిస్తాము. అయితే ఇది సాధారణం గేమర్ కంటే ప్రోగ్రామర్‌కు అర్థం ఏమిటి? సమాధానం సులభం: మేము. మీరు స్ట్రాటజియంలో స్పెయిన్‌గా ఆడుతున్నారని అనుకుందాం. మీ గేమ్‌కు రాష్ట్రం ఉంది: ఎవరు ఏ భూభాగాలను కలిగి ఉన్నారు, ఎవరికి ఎన్ని వనరులు ఉన్నాయి, ఎవరు ఎవరితో పొత్తులో ఉన్నారు, ఎవరితో యుద్ధంలో ఉన్నారు మరియు మొదలైనవి. భవిష్యత్తులో దీన్ని పునరుద్ధరించడానికి మరియు ఆటను కొనసాగించడానికి మేము ఈ సమాచారాన్ని, మా ప్రోగ్రామ్ యొక్క స్థితిని ఏదో ఒకవిధంగా సేవ్ చేయాలి. సీరియలైజేషన్ మరియు డీసరియలైజేషన్ ఖచ్చితంగా దీని కోసం. సీరియలైజేషన్ అనేది ఒక వస్తువు యొక్క స్థితిని బైట్‌ల క్రమంలో నిల్వ చేసే ప్రక్రియ. డీసీరియలైజేషన్ఈ బైట్‌ల నుండి ఒక వస్తువును పునరుద్ధరించే ప్రక్రియ. ఏదైనా జావా వస్తువును బైట్ సీక్వెన్స్‌గా మార్చవచ్చు. మనకు అది ఎందుకు అవసరం? ప్రోగ్రామ్‌లు వాటి స్వంతంగా ఉండవని మేము ఒకటి కంటే ఎక్కువసార్లు చెప్పాము. చాలా తరచుగా, వారు ఇతర ప్రోగ్రామ్‌లు, మార్పిడి డేటా మొదలైన వాటితో పరస్పర చర్య చేస్తారు మరియు బైట్ సీక్వెన్స్ అనుకూలమైన మరియు సమర్థవంతమైన ఆకృతి. ఉదాహరణకు, మన SavedGameవస్తువును బైట్‌ల శ్రేణిగా మార్చవచ్చు, ఈ బైట్‌లను నెట్‌వర్క్ ద్వారా మరొక కంప్యూటర్‌కు పంపవచ్చు, ఆపై రెండవ కంప్యూటర్‌లో ఈ బైట్‌లను తిరిగి జావా ఆబ్జెక్ట్‌గా మార్చవచ్చు! కష్టంగా అనిపిస్తుంది, సరియైనదా? మరియు ఈ ప్రక్రియను అమలు చేయడం బాధాకరంగా ఉంది :/ సంతోషకరంగా, ఇది అలా కాదు! :) జావాలో, దిSerializableసీరియలైజేషన్ ప్రక్రియకు ఇంటర్‌ఫేస్ బాధ్యత వహిస్తుంది. ఈ ఇంటర్‌ఫేస్ చాలా సులభం: మీరు దీన్ని ఉపయోగించడానికి ఒకే పద్ధతిని అమలు చేయవలసిన అవసరం లేదు! మా గేమ్-సేవింగ్ క్లాస్ ఎంత సరళంగా కనిపిస్తుంది:

import java.io.Serializable;
import java.util.Arrays;

public class SavedGame implements Serializable {

   private static final long serialVersionUID = 1L;

   private String[] territoriesInfo;
   private String[] resourcesInfo;
   private String[] diplomacyInfo;

   public SavedGame(String[] territoriesInfo, String[] resourcesInfo, String[] diplomacyInfo){
       this.territoriesInfo = territoriesInfo;
       this.resourcesInfo = resourcesInfo;
       this.diplomacyInfo = diplomacyInfo;
   }

   public String[] getTerritoriesInfo() {
       return territoriesInfo;
   }

   public void setTerritoriesInfo(String[] territoriesInfo) {
       this.territoriesInfo = territoriesInfo;
   }

   public String[] getResourcesInfo() {
       return resourcesInfo;
   }

   public void setResourcesInfo(String[] resourcesInfo) {
       this.resourcesInfo = resourcesInfo;
   }

   public String[] getDiplomacyInfo() {
       return diplomacyInfo;
   }

   public void setDiplomacyInfo(String[] diplomacyInfo) {
       this.diplomacyInfo = diplomacyInfo;
   }

   @Override
   public String toString() {
       return "SavedGame{" +
               "territoriesInfo=" + Arrays.toString(territoriesInfo) +
               ", resourcesInfo=" + Arrays.toString(resourcesInfo) +
               ", diplomacyInfo=" + Arrays.toString(diplomacyInfo) +
               '}';
   }
}

మూడు శ్రేణులు భూభాగాలు, వనరులు మరియు దౌత్యం గురించిన సమాచారానికి బాధ్యత వహిస్తాయి. సీరియలైజ్ చేయదగిన ఇంటర్‌ఫేస్ జావా వర్చువల్ మెషీన్‌కు ఇలా చెబుతుంది: " అంతా సరే — అవసరమైతే, ఈ క్లాస్‌లోని ఆబ్జెక్ట్‌లను సీరియల్‌గా మార్చవచ్చు ". ఒకే ఇంటర్‌ఫేస్ లేని ఇంటర్‌ఫేస్ విచిత్రంగా కనిపిస్తుంది :/ ఇది ఎందుకు అవసరం? ఈ ప్రశ్నకు సమాధానం పైన చూడవచ్చు: ఇది జావా వర్చువల్ మెషీన్‌కు అవసరమైన సమాచారాన్ని అందించడానికి మాత్రమే ఉపయోగపడుతుంది. మా మునుపటి పాఠాలలో ఒకదానిలో, మేము మార్కర్ ఇంటర్‌ఫేస్‌లను క్లుప్తంగా ప్రస్తావించాము . ఇవి ప్రత్యేక సమాచార ఇంటర్‌ఫేస్‌లు, భవిష్యత్తులో జావా మెషీన్‌కు ఉపయోగపడే అదనపు సమాచారంతో మా తరగతులను గుర్తించవచ్చు. మీరు అమలు చేయాల్సిన పద్ధతులు ఏవీ వారికి లేవు.Serializableఆ ఇంటర్‌ఫేస్‌లలో ఒకటి. private static final long serialVersionUIDమరో ముఖ్యమైన విషయం: తరగతిలో మనం నిర్వచించిన వేరియబుల్ ఎందుకు అవసరం ? అది ఎందుకు అవసరం? ఈ ఫీల్డ్ సీరియలైజ్డ్ క్లాస్ వెర్షన్ కోసం ప్రత్యేకమైన ఐడెంటిఫైయర్‌ని కలిగి ఉంది . ఇంటర్‌ఫేస్‌ని అమలు చేసే ఏదైనా తరగతికి ఐడెంటిఫైయర్ Serializableఉంటుంది version. ఇది తరగతిలోని కంటెంట్‌ల ఆధారంగా లెక్కించబడుతుంది: దాని ఫీల్డ్‌లు, అవి ప్రకటించబడిన క్రమం, పద్ధతులు మొదలైనవి. మేము ఫీల్డ్ రకం మరియు/లేదా మా తరగతిలోని ఫీల్డ్‌ల సంఖ్యను మార్చినట్లయితే, సంస్కరణ ఐడెంటిఫైయర్ వెంటనే మారుతుంది . serialVersionUIDతరగతి సీరియల్‌గా ఉన్నప్పుడు కూడా వ్రాయబడుతుంది. మనం డీరియలైజ్ చేయడానికి ప్రయత్నించినప్పుడు, అంటే బైట్‌ల సెట్ నుండి ఒక వస్తువును పునరుద్ధరించడానికి, అనుబంధిత serialVersionUIDవిలువతో పోల్చబడుతుందిserialVersionUIDమా ప్రోగ్రామ్‌లోని తరగతి కోసం. విలువలు సరిపోలకపోతే, java.io. InvalidClassException విసిరివేయబడుతుంది. మేము దీనికి ఉదాహరణను క్రింద చూస్తాము. దీన్ని నివారించడానికి, మేము మా తరగతిలో సంస్కరణ ఐడెంటిఫైయర్‌ను మాన్యువల్‌గా సెట్ చేస్తాము. మా విషయంలో, ఇది కేవలం 1కి సమానంగా ఉంటుంది (కానీ మీకు నచ్చిన ఇతర సంఖ్యను మీరు ప్రత్యామ్నాయం చేయవచ్చు). సరే, మన వస్తువును ధారావాహికగా రూపొందించడానికి ప్రయత్నించడానికి SavedGameమరియు ఏమి జరుగుతుందో చూడడానికి ఇది సమయం!

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class Main {

   public static void main(String[] args) throws IOException {

       // Create our object
       String[] territoryInfo = {"Spain has 6 provinces", "Russia has 10 provinces", "France has 8 provinces"};
       String[] resourcesInfo = {"Spain has 100 gold", "Russia has 80 gold", "France has 90 gold"};
       String[] diplomacyInfo = {"France is at war with Russia, Spain has taken a neutral position"};

       SavedGame savedGame = new SavedGame(territoryInfo, resourcesInfo, diplomacyInfo);

       // Create 2 streams to serialize the object and save it to a file
       FileOutputStream outputStream = new FileOutputStream("C:\\Users\\Username\\Desktop\\save.ser");
       ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);

       // Save the game to a file
       objectOutputStream.writeObject(savedGame);

       // Close the stream and free resources
       objectOutputStream.close();
   }
}

మీరు గమనిస్తే, మేము 2 స్ట్రీమ్‌లను సృష్టించాము: FileOutputStreamమరియు ObjectOutputStream. మొదటిది ఫైల్‌కి డేటాను వ్రాయగలదు మరియు రెండవది వస్తువులను బైట్‌లుగా మారుస్తుంది. మీరు ఇప్పటికే ఇలాంటి "సమూహ" నిర్మాణాలను చూసారు, ఉదాహరణకు, new BufferedReader(new InputStreamReader(...)), మునుపటి పాఠాలలో, కాబట్టి అవి మిమ్మల్ని భయపెట్టకూడదు :) రెండు స్ట్రీమ్‌ల యొక్క అటువంటి "గొలుసు"ని సృష్టించడం ద్వారా, మేము రెండు పనులను చేస్తాము: మేము వస్తువును SavedGameసెట్‌గా మారుస్తాము బైట్‌లను మరియు పద్ధతిని ఉపయోగించి ఫైల్‌లో సేవ్ చేయండి writeObject(). మరియు, మార్గం ద్వారా, మేము కూడా మాకు ఏమి చూడండి లేదు! ఫైల్‌ని చూసే సమయం వచ్చింది! *గమనిక: మీరు ముందుగా ఫైల్‌ను సృష్టించాల్సిన అవసరం లేదు. ఆ పేరుతో ఫైల్ ఉనికిలో లేకుంటే, అది స్వయంచాలకంగా సృష్టించబడుతుంది* మరియు దాని కంటెంట్‌లు ఇక్కడ ఉన్నాయి!

¬н sr SavedGame [ diplomacyInfot [Ljava/lang/String;[ resourcesInfoq ~ [ territoriesInfoq ~ xpur [Ljava.lang.String;­ТVзй{G xp t pФранция воюет СЃ Россией, Испания заняла позицию нейтралитетаuq ~ t "РЈ Испании 100 золотаt РЈ Р РѕСЃСЃРёРё 80 золотаt !РЈ Франции 90 золотаuq ~ t &РЈ Испании 6 провинцийt %РЈ Р РѕСЃСЃРёРё 10 провинцийt &РЈ Франции 8 провинций

అయ్యో :( మా ప్రోగ్రామ్ పని చేయలేదని అనిపిస్తుంది :( నిజానికి, ఇది పని చేసింది. మేము ఫైల్‌కి కేవలం వస్తువు లేదా టెక్స్ట్ మాత్రమే కాకుండా బైట్‌ల సెట్‌ను పంపినట్లు మీకు గుర్తుందా? సరే, ఇదే బైట్‌ల సెట్ ఇలా కనిపిస్తుంది :) ఇది మా సేవ్ చేయబడిన గేమ్! మనం మన అసలు వస్తువును పునరుద్ధరించాలనుకుంటే, అంటే ఆటను ప్రారంభించి, మనం ఆపివేసిన చోట నుండి కొనసాగించాలనుకుంటే, మనకు రివర్స్ ప్రాసెస్ అవసరం: డీరియలైజేషన్. ఇది మనలో ఎలా ఉంటుందో ఇక్కడ ఉంది కేసు:

import java.io.*;

public class Main {

   public static void main(String[] args) throws IOException, ClassNotFoundException {

       FileInputStream fileInputStream = new FileInputStream("C:\\Users\\Username\\Desktop\\save.ser");
       ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);

       SavedGame savedGame = (SavedGame) objectInputStream.readObject();

       System.out.println(savedGame);
   }
}

మరియు ఇక్కడ ఫలితం ఉంది!

SavedGame{territoriesInfo=["Spain has 6 provinces, Russia has 10 provinces, France has 8 provinces], resourcesInfo=[Spain has 100 gold, Russia has 80 gold, France has 90 gold], diplomacyInfo=[France is at war with Russia, Spain has taken a neutral position]}

అద్భుతమైన! మేము మొదట మా గేమ్ స్థితిని ఫైల్‌కి సేవ్ చేసి, ఆపై ఫైల్ నుండి పునరుద్ధరించగలిగాము. ఇప్పుడు అదే పనిని చేయడానికి ప్రయత్నిద్దాం, కానీ మా SavedGameతరగతికి వెర్షన్ ఐడెంటిఫైయర్ లేకుండా. మేము మా రెండు తరగతులను తిరిగి వ్రాయము. వారి కోడ్ అలాగే ఉంటుంది, కానీ మేము తరగతి private static final long serialVersionUIDనుండి తీసివేస్తాము SavedGame. సీరియలైజేషన్ తర్వాత మా వస్తువు ఇక్కడ ఉంది:

¬н sr SavedGameі€MіuОm‰ [ diplomacyInfot [Ljava/lang/String;[ resourcesInfoq ~ [ territoriesInfoq ~ xpur [Ljava.lang.String;­ТVзй{G xp t pФранция воюет СЃ Россией, Испания заняла позицию нейтралитетаuq ~ t "РЈ Испании 100 золотаt РЈ Р РѕСЃСЃРёРё 80 золотаt !РЈ Франции 90 золотаuq ~ t &РЈ Испании 6 провинцийt %РЈ Р РѕСЃСЃРёРё 10 провинцийt &РЈ Франции 8 провинций

కానీ మనం దానిని డీరియలైజ్ చేయడానికి ప్రయత్నించినప్పుడు ఏమి జరుగుతుందో చూడండి:

InvalidClassException: local class incompatible: stream classdesc serialVersionUID = -196410440475012755, local class serialVersionUID = -6675950253085108747

ఇది మేము పైన పేర్కొన్న చాలా మినహాయింపు. మార్గం ద్వారా, మేము ముఖ్యమైనదాన్ని కోల్పోయాము. స్ట్రింగ్స్ మరియు ప్రిమిటివ్‌లను సులభంగా సీరియలైజ్ చేయవచ్చని అర్ధమే: దీన్ని చేయడానికి జావా బహుశా ఒక రకమైన అంతర్నిర్మిత యంత్రాంగాన్ని కలిగి ఉంటుంది. కానీ మన serializableతరగతిలో ఆదిమాంశాలు లేని ఫీల్డ్‌లు ఉంటే, కానీ ఇతర వస్తువులకు సూచనలు ఉంటే? ఉదాహరణకు, మన తరగతితో కలిసి పనిచేయడానికి విడిగా TerritoriesInfoమరియు ResourcesInfoతరగతులను సృష్టిద్దాం . DiplomacyInfoSavedGame

public class TerritoriesInfo {
  
   private String info;

   public TerritoriesInfo(String info) {
       this.info = info;
   }

   public String getInfo() {
       return info;
   }

   public void setInfo(String info) {
       this.info = info;
   }

   @Override
   public String toString() {
       return "TerritoriesInfo{" +
               "info='" + info + '\'' +
               '}';
   }
}

public class ResourcesInfo {

   private String info;

   public ResourcesInfo(String info) {
       this.info = info;
   }

   public String getInfo() {
       return info;
   }

   public void setInfo(String info) {
       this.info = info;
   }

   @Override
   public String toString() {
       return "ResourcesInfo{" +
               "info='" + info + '\'' +
               '}';
   }
}

public class DiplomacyInfo {

   private String info;

   public DiplomacyInfo(String info) {
       this.info = info;
   }

   public String getInfo() {
       return info;
   }

   public void setInfo(String info) {
       this.info = info;
   }

   @Override
   public String toString() {
       return "DiplomacyInfo{" +
               "info='" + info + '\'' +
               '}';
   }
}

మరియు ఇప్పుడు ఒక ప్రశ్న తలెత్తుతుంది: మన మార్చబడిన తరగతిని సీరియలైజ్ చేయాలనుకుంటే ఈ తరగతులన్నీ అవసరమా ?SerializableSavedGame

import java.io.Serializable;
import java.util.Arrays;

public class SavedGame implements Serializable {

   private TerritoriesInfo territoriesInfo;
   private ResourcesInfo resourcesInfo;
   private DiplomacyInfo diplomacyInfo;

   public SavedGame(TerritoriesInfo territoriesInfo, ResourcesInfo resourcesInfo, DiplomacyInfo diplomacyInfo) {
       this.territoriesInfo = territoriesInfo;
       this.resourcesInfo = resourcesInfo;
       this.diplomacyInfo = diplomacyInfo;
   }

   public TerritoriesInfo getTerritoriesInfo() {
       return territoriesInfo;
   }

   public void setTerritoriesInfo(TerritoriesInfo territoriesInfo) {
       this.territoriesInfo = territoriesInfo;
   }

   public ResourcesInfo getResourcesInfo() {
       return resourcesInfo;
   }

   public void setResourcesInfo(ResourcesInfo resourcesInfo) {
       this.resourcesInfo = resourcesInfo;
   }

   public DiplomacyInfo getDiplomacyInfo() {
       return diplomacyInfo;
   }

   public void setDiplomacyInfo(DiplomacyInfo diplomacyInfo) {
       this.diplomacyInfo = diplomacyInfo;
   }

   @Override
   public String toString() {
       return "SavedGame{" +
               "territoriesInfo=" + territoriesInfo +
               ", resourcesInfo=" + resourcesInfo +
               ", diplomacyInfo=" + diplomacyInfo +
               '}';
   }
}

సరే, దీనిని పరీక్షిద్దాం! అన్నింటినీ అలాగే వదిలేసి, ఆబ్జెక్ట్‌ని సీరియలైజ్ చేయడానికి ప్రయత్నిద్దాం SavedGame:

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class Main {

   public static void main(String[] args) throws IOException {

       // Create our object
       TerritoryInfo territoryInfo = new TerritoryInfo("Spain has 6 provinces, Russia has 10 provinces, France has 8 provinces");
       ResourceInfo resourceInfo = new ResourceInfo("Spain has 100 gold, Russia has 80 gold, France has 90 gold");
       DiplomacyInfo diplomacyInfo =  new DiplomacyInfo("France is at war with Russia, Spain has taken a neutral position");


       SavedGame savedGame = new SavedGame(territoriesInfo, resourcesInfo, diplomacyInfo);

       FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Username\\Desktop\\save.ser");
       ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);

       objectOutputStream.writeObject(savedGame);

       objectOutputStream.close();
   }
}

ఫలితం:

Exception in thread "main" java.io.NotSerializableException: DiplomacyInfo

ఇది పని చేయలేదు! సాధారణంగా, ఇది మా ప్రశ్నకు సమాధానం. ఆబ్జెక్ట్ సీరియలైజ్ చేయబడినప్పుడు, దాని ఇన్‌స్టాన్స్ వేరియబుల్స్ ద్వారా సూచించబడిన అన్ని వస్తువులు సీరియలైజ్ చేయబడతాయి. మరియు ఆ వస్తువులు ఇతర వస్తువులను కూడా సూచిస్తే, అవి కూడా క్రమీకరించబడతాయి. మరియు అందువలన ప్రకటన అనంతం. ఈ గొలుసులోని అన్ని తరగతులు తప్పనిసరిగా ఉండాలిSerializable , లేకుంటే వాటిని సీరియల్ చేయడం అసాధ్యం మరియు మినహాయింపు విసిరివేయబడుతుంది. మార్గం ద్వారా, ఇది రహదారిపై సమస్యలను సృష్టించవచ్చు. ఉదాహరణకు, మనం సీరియల్ చేస్తున్నప్పుడు తరగతిలో భాగం అవసరం లేకుంటే మనం ఏమి చేయాలి? లేదా, ఉదాహరణకు, TerritoryInfoఏదైనా మూడవ పక్షం లైబ్రరీలో భాగంగా తరగతి మా వద్దకు వస్తే ఏమి చేయాలి. మరియు అది కాదని అనుకుందాం Serializableమరియు తదనుగుణంగా, మేము దానిని మార్చలేము. TerritoryInfoమనకి ఫీల్డ్‌ని జోడించలేమని తేలిందిSavedGameతరగతి, ఎందుకంటే అలా చేయడం వల్ల తరగతి మొత్తం SavedGameసీరియలైజ్ చేయబడదు! అది ఒక సమస్య :/ జావాలో, ఈ రకమైన సమస్యలు transientకీవర్డ్‌ని ఉపయోగించి పరిష్కరించబడతాయి. మీరు ఈ కీవర్డ్‌ని మీ తరగతికి చెందిన ఫీల్డ్‌కి జోడిస్తే, ఆ ఫీల్డ్ సీరియలైజ్ చేయబడదు. తరగతి యొక్క ఉదాహరణ ఫీల్డ్‌లలో ఒకదానిని తాత్కాలికంగా చేయడానికి ప్రయత్నిద్దాం SavedGame. అప్పుడు మేము ఒక వస్తువును సీరియల్ చేసి పునరుద్ధరిస్తాము.

import java.io.Serializable;

public class SavedGame implements Serializable {

   private transient TerritoriesInfo territoriesInfo;
   private ResourcesInfo resourcesInfo;
   private DiplomacyInfo diplomacyInfo;

   public SavedGame(TerritoriesInfo territoriesInfo, ResourcesInfo resourcesInfo, DiplomacyInfo diplomacyInfo) {
       this.territoriesInfo = territoriesInfo;
       this.resourcesInfo = resourcesInfo;
       this.diplomacyInfo = diplomacyInfo;
   }

   // ...getters, setters, toString()
}



import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class Main {

   public static void main(String[] args) throws IOException {

       // Create our object
       TerritoryInfo territoryInfo = new TerritoryInfo("Spain has 6 provinces, Russia has 10 provinces, France has 8 provinces");
       ResourceInfo resourceInfo = new ResourceInfo("Spain has 100 gold, Russia has 80 gold, France has 90 gold");
       DiplomacyInfo diplomacyInfo =  new DiplomacyInfo("France is at war with Russia, Spain has taken a neutral position");


       SavedGame savedGame = new SavedGame(territoriesInfo, resourcesInfo, diplomacyInfo);

       FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Username\\Desktop\\save.ser");
       ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);

       objectOutputStream.writeObject(savedGame);

       objectOutputStream.close();
   }
}


import java.io.*;

public class Main {

   public static void main(String[] args) throws IOException, ClassNotFoundException {

       FileInputStream fileInputStream = new FileInputStream("C:\\Users\\Username\\Desktop\\save.ser");
       ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);

       SavedGame savedGame = (SavedGame) objectInputStream.readObject();

       System.out.println(savedGame);

       objectInputStream.close();


   }
}

మరియు ఇక్కడ ఫలితం ఉంది:

SavedGame{territoriesInfo=null, resourcesInfo=ResourcesInfo{info='Spain has 100 gold, Russia has 80 gold, France has 90 gold'}, diplomacyInfo=DiplomacyInfo{info='France is at war with Russia, Spain has taken a neutral position'}}

అదనంగా, ఫీల్డ్‌కు ఏ విలువ కేటాయించబడుతుందనే మా ప్రశ్నకు మేము సమాధానం పొందాము transient. ఇది డిఫాల్ట్ విలువను కేటాయించబడుతుంది. వస్తువుల కోసం, ఇది null. మీరు సీరియలైజేషన్‌పై ఈ అద్భుతమైన కథనాన్ని చదవడానికి మీకు కొన్ని నిమిషాలు మిగిలి ఉన్నప్పుడు. ఇది ఇంటర్‌ఫేస్‌ను కూడా ప్రస్తావిస్తుంది Externalizable, దాని గురించి మనం తదుపరి పాఠంలో మాట్లాడుతాము. అదనంగా, "హెడ్-ఫస్ట్ జావా" పుస్తకంలో ఈ అంశంపై ఒక అధ్యాయం ఉంది. కొంచెం శ్రద్ధ పెట్టండి :)