జావాలో సీరియలైజేషన్ మరియు డీరియలైజేషన్

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

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

public class SavedGame implements Serializable {

   private static final long serialVersionUID = 1L;

   private String[] territoryInfo;
   private String[] resourceInfo;
   private String[] diplomacyInfo;

   public SavedGame(String[] territoryInfo, String[] resourceInfo, String[] diplomacyInfo){
       this.territoryInfo = territoryInfo;
       this.resourceInfo = resourceInfo;
       this.diplomacyInfo = diplomacyInfo;
   }

   public String[] getTerritoryInfo() {
       return territoryInfo;
   }

   public void setTerritoryInfo(String[] territoryInfo) {
       this.territoryInfo = territoryInfo;
   }

   public String[] getResourceInfo() {
       return resourceInfo;
   }

   public void setResourceInfo(String[] resourceInfo) {
       this.resourceInfo = resourceInfo;
   }

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

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

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

భూభాగాలు, వనరులు మరియు దౌత్యం గురించిన సమాచారానికి మూడు శ్రేణులు బాధ్యత వహిస్తాయి మరియు సీరియలైజ్ చేయదగిన ఇంటర్‌ఫేస్ జావా మెషీన్‌కి ఇలా చెబుతుంది: ' ఈ తరగతి వస్తువులను సీరియల్‌గా మార్చగలిగితే అంతా బాగానే ఉంటుంది '. ఒకే ఇంటర్‌ఫేస్ లేని ఇంటర్‌ఫేస్ విచిత్రంగా కనిపిస్తుంది :/ ఇది ఎందుకు అవసరం? ఆ ప్రశ్నకు సమాధానం పైన ఇవ్వబడింది: జావా యంత్రానికి అవసరమైన సమాచారాన్ని అందించడానికి మాత్రమే ఇది అవసరం. గత పాఠంలో, మేము మార్కర్ ఇంటర్‌ఫేస్‌లను క్లుప్తంగా ప్రస్తావించాము. ఇవి ప్రత్యేక సమాచార ఇంటర్‌ఫేస్‌లు, భవిష్యత్తులో జావా మెషీన్‌కు ఉపయోగపడే అదనపు సమాచారంతో మా తరగతులను గుర్తించవచ్చు. మీరు అమలు చేయాల్సిన పద్ధతులు ఏవీ వారికి లేవు. ఇదిగో సీరియలైజబుల్ — అటువంటి ఇంటర్‌ఫేస్ ఒకటి. ఇక్కడ మరొక ముఖ్యమైన విషయం ఉంది: మనకు ఎందుకు అవసరంమేము తరగతిలో నిర్వచించిన ప్రైవేట్ స్టాటిక్ ఫైనల్ లాంగ్ సీరియల్VersionUID వేరియబుల్? ఈ ఫీల్డ్ సీరియలైజ్డ్ క్లాస్ యొక్క ప్రత్యేక వెర్షన్ ఐడెంటిఫైయర్‌ని కలిగి ఉంది. సీరియలైజబుల్ ఇంటర్‌ఫేస్‌ని అమలు చేసే ప్రతి తరగతికి వెర్షన్ ఐడెంటిఫైయర్ ఉంటుంది. ఇది క్లాస్ యొక్క కంటెంట్ - ఫీల్డ్‌లు మరియు వాటి డిక్లరేషన్ ఆర్డర్ మరియు పద్ధతులు మరియు వాటి డిక్లరేషన్ ఆర్డర్ ఆధారంగా నిర్ణయించబడుతుంది. మరియు మేము ఫీల్డ్ రకాన్ని మరియు/లేదా మా తరగతిలోని ఫీల్డ్‌ల సంఖ్యను మార్చినట్లయితే, సంస్కరణ ఐడెంటిఫైయర్ తక్షణమే మారుతుంది. తరగతి సీరియలైజ్ చేయబడినప్పుడు కూడా 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[] resourceInfo = {"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, resourceInfo, 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 release resources
       objectOutputStream.close();
   }
}

మీరు చూడగలిగినట్లుగా, మేము 2 స్ట్రీమ్‌లను సృష్టించాము: FileOutputStream మరియు ObjectOutputStream . మొదటిది ఫైల్‌కు డేటాను ఎలా వ్రాయాలో తెలుసు, మరియు రెండవది వస్తువులను బైట్‌లుగా మారుస్తుంది. మీరు ఇప్పటికే సారూప్య సమూహ నిర్మాణాలను చూసారు, ఉదాహరణకు, కొత్త బఫర్డ్ రీడర్(కొత్త ఇన్‌పుట్‌స్ట్రీమ్‌రీడర్(...)) , మునుపటి పాఠాలలో, వారు మిమ్మల్ని భయపెట్టకూడదు :) ఈ రెండు స్ట్రీమ్‌ల గొలుసును సృష్టించడం ద్వారా, మేము రెండు పనులను చేస్తాము: మేము SavedGame ఆబ్జెక్ట్‌ని బైట్‌ల శ్రేణిగా మారుస్తాము మరియు రైట్‌ఆబ్జెక్ట్() పద్ధతిని ఉపయోగించి దానిని ఫైల్‌లో సేవ్ చేస్తాము. మరియు, మార్గం ద్వారా, మేము కూడా మాకు ఏమి చూడండి లేదు! ఫైల్‌ని చూసే సమయం వచ్చింది! *గమనిక: ముందుగా ఫైల్‌ను సృష్టించాల్సిన అవసరం లేదు. పేర్కొన్న పేరుతో ఫైల్ ఉనికిలో లేకుంటే, అది స్వయంచాలకంగా సృష్టించబడుతుంది* మరియు దాని కంటెంట్‌లు ఇక్కడ ఉన్నాయి: ¬н sr SavedGame [ diplomacyInfot [Ljava/lang/String;[ resourceInfoq ~ [ territoryInfoq ~ xpur [Ljava.lang. స్ట్రింగ్;¬ТVзй{G xp t pФранция воюет СЃ Россией, ЃРёРµР№, аняла позицию нейтралит етаuq ~ t "РЈ Р˜СЃРїР°РЅРёРё 100 золотаt РЈ Р РѕСРСЃ Р°t !РЈ Франции 90 Р·РѕР »РѕС‚Р°uq ~ t &РЈ Р˜СЃРїР°РЅРёРё 6 РїСЂРѕРІРёРЅС†РРёР№t СРРЕ СРЕ СРЕ ఎసి ఓహ్, ఓహ్ :( మా ప్రోగ్రామ్ పని చేయలేదని అనిపిస్తుంది : ( వాస్తవానికి, ఇది పని చేసింది. మేము ఫైల్‌కి కేవలం ఒక వస్తువు లేదా వచనాన్ని కాకుండా బైట్‌ల క్రమాన్ని పంపినట్లు మీకు గుర్తుందా? సరే, ఇదే ఈ బైట్ సీక్వెన్స్ కనిపిస్తోంది :) ఇది మా సేవ్ చేయబడిన గేమ్! మనం మన అసలు వస్తువుని పునరుద్ధరించాలనుకుంటే, అంటే ఆటను ప్రారంభించి, మనం వదిలివేసిన చోట నుండి కొనసాగించాలనుకుంటే, మనకు రివర్స్ ప్రాసెస్ అవసరం: డీరియలైజేషన్. ఇది మనకు ఇలా కనిపిస్తుంది:

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{territoryInfo=[స్పెయిన్‌కు 6 ప్రావిన్సులు, రష్యాకు 10 ప్రావిన్సులు, ఫ్రాన్స్‌కు 8 ప్రావిన్సులు], resourceInfo=[స్పెయిన్‌లో 100 బంగారం, రష్యాకు 80 బంగారు, ఫ్రాన్స్‌కు 90 బంగారం], డిప్లమసీఇన్ఫో=[ఫ్రాన్స్ రష్యాతో యుద్ధం చేస్తోంది, స్పెయిన్ తటస్థ స్థితిని తీసుకుంది]} అద్భుతమైనది! మేము మొదట మా గేమ్ స్థితిని ఫైల్‌కి సేవ్ చేసి, ఆపై ఫైల్ నుండి దాన్ని పునరుద్ధరించగలిగాము. ఇప్పుడు అదే పనిని చేయడానికి ప్రయత్నిద్దాం, కానీ మేము మా SavedGame తరగతి నుండి సంస్కరణ ఐడెంటిఫైయర్‌ని తీసివేస్తాము. మేము మా రెండు తరగతులను తిరిగి వ్రాయము. వారి కోడ్ ఒకే విధంగా ఉంటుంది. మేము SavedGame క్లాస్ నుండి ప్రైవేట్ స్టాటిక్ ఫైనల్ లాంగ్ సీరియల్VersionUIDని తీసివేస్తాము . సీరియలైజేషన్ తర్వాత మా వస్తువు ఇక్కడ ఉంది: ¬н sr SavedGameі€MіuОm‰ [ diplomacyInfot [Ljava/lang/String;[ resourceInfoq ~ [ territoryInfoq ~ xpur [Ljava.lang.String;¬ТVзй{G xp t pРР° оюет СЃ Россией, Р˜СЃРїР°РЅРёСЏ заняла позицию нацию РЈ Р˜СЃРїР°РЅРёРё 100 золотР°t RA Р˜СЃРїР°РЅРёРё 6 провинцийt %РЈ ఆర్ రస్సి Р№ కానీ మేము దానిని డీరియలైజ్ చేయడానికి ప్రయత్నించినప్పుడు ఏమి జరుగుతుందో చూడండి: InvalidClassException: స్థానిక తరగతి అననుకూలమైనది: stream classdesc serialVersionUID = -196410440475012755, స్థానిక తరగతి serialVersionUID = -6675950253085108747 మార్గం ద్వారా, మేము ముఖ్యమైనదాన్ని కోల్పోయాము. సహజంగానే, స్ట్రింగ్స్ మరియు ప్రిమిటివ్‌లు సులభంగా సీరియలైజ్ చేయబడతాయి: జావా ఖచ్చితంగా దీని కోసం కొంత అంతర్నిర్మిత యంత్రాంగాన్ని కలిగి ఉంది. కానీ మన సీరియలైజ్ చేయదగిన తరగతిలో ఆదిమాంశాలు లేని ఫీల్డ్‌లు ఉంటే, కానీ ఇతర వస్తువులకు సూచనలు ఉంటే? ఉదాహరణకు, మా SavedGame క్లాస్‌తో పని చేయడానికి ప్రత్యేక TerritoryInfo , ResourceInfo మరియు DiplomacyInfo తరగతిని సృష్టిద్దాం .

public class TerritoryInfo {

   private String info;

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

   public String getInfo() {
       return info;
   }

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

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

public class ResourceInfo {

   private String info;

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

   public String getInfo() {
       return info;
   }

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

   @Override
   public String toString() {
       return "ResourceInfo{" +
               "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 + '\'' +
               '}';
   }
}

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

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

public class SavedGame implements Serializable {

   private TerritoryInfo territoryInfo;
   private ResourceInfo resourceInfo;
   private DiplomacyInfo diplomacyInfo;

   public SavedGame(TerritoryInfo territoryInfo, ResourceInfo resourceInfo, DiplomacyInfo diplomacyInfo) {
       this.territoryInfo = territoryInfo;
       this.resourceInfo = resourceInfo;
       this.diplomacyInfo = diplomacyInfo;
   }

   public TerritoryInfo getTerritoryInfo() {
       return territoryInfo;
   }

   public void setTerritoryInfo(TerritoryInfo territoryInfo) {
       this.territoryInfo = territoryInfo;
   }

   public ResourceInfo getResourceInfo() {
       return resourceInfo;
   }

   public void setResourceInfo(ResourceInfo resourceInfo) {
       this.resourceInfo = resourceInfo;
   }

   public DiplomacyInfo getDiplomacyInfo() {
       return diplomacyInfo;
   }

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

   @Override
   public String toString() {
       return "SavedGame{" +
               "territoryInfo=" + territoryInfo +
               ", resourceInfo=" + resourceInfo +
               ", 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(territoryInfo, resourceInfo, diplomacyInfo);

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

       objectOutputStream.writeObject(savedGame);

       objectOutputStream.close();
   }
}

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

import java.io.Serializable;

public class SavedGame implements Serializable {

   private transient TerritoryInfo territoryInfo;
   private ResourceInfo resourceInfo;
   private DiplomacyInfo diplomacyInfo;

   public SavedGame(TerritoryInfo territoryInfo, ResourceInfo resourceInfo, DiplomacyInfo diplomacyInfo) {
       this.territoryInfo = territoryInfo;
       this.resourceInfo = resourceInfo;
       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(territoryInfo, resourceInfo, 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{territoryInfo=null, resourceInfo=ResourceInfo{info='స్పెయిన్‌కు 100 బంగారు, రష్యాకు 80 బంగారు, ఫ్రాన్స్‌కు 90 బంగారు'}, diplomacyInfo=DiplomacyInfo{info='ఫ్రాన్స్ రష్యా, స్పెయిన్‌తో యుద్ధం చేస్తోంది. ఒక తటస్థ స్థితిని తీసుకున్నారు'}} అంటే, తాత్కాలిక ఫీల్డ్‌కు ఏ విలువ కేటాయించబడుతుందనే ప్రశ్నకు మేము సమాధానం పొందాము . దీనికి డిఫాల్ట్ విలువ కేటాయించబడుతుంది. వస్తువుల కోసం, ఇది శూన్యం . మీరు 'హెడ్-ఫస్ట్ జావా' పుస్తకంలో ఈ అంశంపై అద్భుతమైన అధ్యాయాన్ని చదవవచ్చు, దానిపై శ్రద్ధ వహించండి :)