"హాయ్, అమిగో!"
"హాయ్, బిలాబో!"
"ఈ రోజు నేను మీకు మార్కర్ ఇంటర్ఫేస్ల గురించి చెబుతాను ."
"మార్కర్ ఇంటర్ఫేస్లు పద్ధతులు లేని ఇంటర్ఫేస్లు. ఒక తరగతి అటువంటి ఇంటర్ఫేస్ను అమలు చేసినప్పుడు, అది దాని ద్వారా గుర్తించబడిందని మేము చెప్తాము."
"ఈ ఇంటర్ఫేస్ల ఉదాహరణలు: క్లోనబుల్, సీరియలైజ్ చేయదగినవి, రిమోట్ ."
" సీరియలైజేషన్కు మద్దతు ఇచ్చే తరగతులను గుర్తించడానికి సీరియలైజ్ చేయదగిన ఇంటర్ఫేస్ ఉపయోగించబడుతుంది, ఈ తరగతుల ఉదాహరణలు స్వయంచాలకంగా సీరియలైజ్ చేయబడతాయని మరియు డీరియలైజ్ చేయబడతాయని సూచిస్తుంది."
" రిమోట్ ఇంటర్ఫేస్ అనేది రిమోట్ ఎగ్జిక్యూషన్కు మద్దతిచ్చే వస్తువులను గుర్తించడానికి ఉపయోగించబడుతుంది, అనగా మరొక జావా వర్చువల్ మెషీన్ మరియు/లేదా వేరే కంప్యూటర్ నుండి ఉపయోగించబడే పద్ధతులు."
" క్లోనింగ్కు మద్దతు ఇచ్చే తరగతులను గుర్తించడానికి క్లోనబుల్ ఇంటర్ఫేస్ ఉపయోగించబడుతుంది."
"ఓహ్, క్లోనింగ్ లేదా కాపీయింగ్ గురించి."
"రెండు రకాల కాపీలు ఉన్నాయి: నిస్సార మరియు లోతైన."
" నిస్సారంగా కాపీ చేయడం అనేది ఆబ్జెక్ట్ యొక్క కాపీని సృష్టించడం, అది సూచించే ఏదైనా వస్తువుకు నకిలీలను చేయకుండా."
" డీప్ కాపీయింగ్లో ఆబ్జెక్ట్ని డూప్లికేట్ చేయడం, అది సూచించే వస్తువులు మరియు ఆ వస్తువులు సూచించే వస్తువులు మొదలైనవాటితో సహా."
"విశ్వసనీయంగా లోతైన క్లోన్ను రూపొందించడానికి నిజంగా మంచి మార్గం ఉంది."
"డెవలపర్లు క్లాస్ను క్లోన్ చేయదగినదిగా గుర్తించడం మర్చిపోయినా కూడా ఈ పద్ధతి పని చేస్తుంది. "ఆబ్జెక్ట్లు తప్పనిసరిగా సీరియలైజ్గా ఉండాలి."
"మీరు దీన్ని ఎలా చేస్తారో ఇక్కడ ఉంది:"
1) మెమరీలో బఫర్ (బైట్ అర్రే)ని సృష్టించండి.
2) ఆబ్జెక్ట్ మరియు సబ్బ్జెక్ట్లను బఫర్లోకి సీరియలైజ్ చేయండి.
3) బఫర్లో సేవ్ చేయబడిన ఆబ్జెక్ట్ హైరార్కీని డీసీరియలైజ్ చేయండి.
BigObject objectOriginal = new BigObject();
ByteArrayOutputStream writeBuffer = new ByteArrayOutputStream();
ObjectOutputStream outputStream = new ObjectOutputStream(writeBuffer);
outputStream.writeObject(objectOriginal);
outputStream.close();
byte[] buffer = writeBuffer.toByteArray();
ByteArrayInputStream readBuffer = new ByteArrayInputStream(buffer);
ObjectInputStream inputStream = new ObjectInputStream(readBuffer);
BigObject objectCopy = (BigObject)inputStream.readObject();
"మొదటి పంక్తిలో, మేము ఆబ్జెక్ట్ ఒరిజినల్ని సృష్టిస్తాము , దానిని మేము క్లోన్ చేస్తాము. ఆబ్జెక్ట్ మరియు దానిలోని అన్ని సబ్జెక్ట్లు తప్పనిసరిగా సీరియలైజేషన్కు మద్దతు ఇవ్వాలి."
"మూడవ లైన్లో, మేము ByteArrayOutputStream ని సృష్టిస్తాము , ఇది కొత్త డేటా జోడించబడినప్పుడు డైనమిక్గా విస్తరిస్తుంది (అరేలిస్ట్ లాగా)."
"4వ పంక్తిలో, మేము ObjectOutputStream ని సృష్టిస్తాము , ఇది సీరియలైజేషన్ కోసం ఉపయోగించబడుతుంది."
"పంక్తి 5లో, అవుట్పుట్స్ట్రీమ్ని ఉపయోగించి ఆబ్జెక్ట్ ఒరిజినల్ని బైట్ అర్రేగా సీరియల్గా మారుస్తాము మరియు రైట్బఫర్లో సేవ్ చేస్తాము ."
"పంక్తి 8లో, మేము రైట్బఫర్ని సాధారణ బైట్ శ్రేణిలోకి మారుస్తాము . తర్వాత మేము ఈ శ్రేణి నుండి మా కొత్త వస్తువును 'చదువుతాము'."
"పంక్తి 9లో, మేము బఫర్ని బైట్అరేఇన్పుట్స్ట్రీమ్గా మారుస్తాము , దాని నుండి ఇన్పుట్ స్ట్రీమ్ లాగా చదవండి. "
"10వ పంక్తిలో, ఆబ్జెక్ట్ను చదవడానికి (డీరియలైజ్ చేయడానికి) మేము రీడ్బఫర్ని ఆబ్జెక్ట్ఇన్పుట్స్ట్రీమ్ కన్స్ట్రక్టర్కి పంపుతాము . "
"11వ పంక్తిలో, మేము మా వస్తువును చదివి దానిని BigObject గా మారుస్తాము ."
"ఏమనుకుంటున్నారు?"
"ఇది అందంగా ఉంది."
"మరియు మార్గం ద్వారా, కోడ్ వేర్వేరు రంగులలో హైలైట్ చేయబడినప్పుడు, అర్థం చేసుకోవడం చాలా సులభం."