మార్కర్ ఇంటర్‌ఫేస్‌లు మరియు డీప్ కాపీలు

"హాయ్, అమిగో!"

"హాయ్, బిలాబో!"

"ఈ రోజు నేను మీకు మార్కర్ ఇంటర్‌ఫేస్‌ల గురించి చెబుతాను ."

"మార్కర్ ఇంటర్‌ఫేస్‌లు పద్ధతులు లేని ఇంటర్‌ఫేస్‌లు. ఒక తరగతి అటువంటి ఇంటర్‌ఫేస్‌ను అమలు చేసినప్పుడు, అది దాని ద్వారా గుర్తించబడిందని మేము చెప్తాము."

"ఈ ఇంటర్‌ఫేస్‌ల ఉదాహరణలు: క్లోనబుల్, సీరియలైజ్ చేయదగినవి, రిమోట్ ."

" సీరియలైజేషన్‌కు మద్దతు ఇచ్చే తరగతులను గుర్తించడానికి సీరియలైజ్ చేయదగిన ఇంటర్‌ఫేస్ ఉపయోగించబడుతుంది, ఈ తరగతుల ఉదాహరణలు స్వయంచాలకంగా సీరియలైజ్ చేయబడతాయని మరియు డీరియలైజ్ చేయబడతాయని సూచిస్తుంది."

" రిమోట్ ఇంటర్‌ఫేస్ అనేది రిమోట్ ఎగ్జిక్యూషన్‌కు మద్దతిచ్చే వస్తువులను గుర్తించడానికి ఉపయోగించబడుతుంది, అనగా మరొక జావా వర్చువల్ మెషీన్ మరియు/లేదా వేరే కంప్యూటర్ నుండి ఉపయోగించబడే పద్ధతులు."

" క్లోనింగ్‌కు మద్దతు ఇచ్చే తరగతులను గుర్తించడానికి క్లోనబుల్ ఇంటర్‌ఫేస్ ఉపయోగించబడుతుంది."

"ఓహ్, క్లోనింగ్ లేదా కాపీయింగ్ గురించి."

"రెండు రకాల కాపీలు ఉన్నాయి: నిస్సార మరియు లోతైన."

" నిస్సారంగా కాపీ చేయడం అనేది ఆబ్జెక్ట్ యొక్క కాపీని సృష్టించడం, అది సూచించే ఏదైనా వస్తువుకు నకిలీలను చేయకుండా."

" డీప్ కాపీయింగ్‌లో ఆబ్జెక్ట్‌ని డూప్లికేట్ చేయడం, అది సూచించే వస్తువులు మరియు ఆ వస్తువులు సూచించే వస్తువులు మొదలైనవాటితో సహా."

"విశ్వసనీయంగా లోతైన క్లోన్‌ను రూపొందించడానికి నిజంగా మంచి మార్గం ఉంది."

"డెవలపర్‌లు క్లాస్‌ను క్లోన్ చేయదగినదిగా గుర్తించడం మర్చిపోయినా కూడా ఈ పద్ధతి పని చేస్తుంది. "ఆబ్జెక్ట్‌లు తప్పనిసరిగా సీరియలైజ్‌గా ఉండాలి."

"మీరు దీన్ని ఎలా చేస్తారో ఇక్కడ ఉంది:"

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 గా మారుస్తాము ."

"ఏమనుకుంటున్నారు?"

"ఇది అందంగా ఉంది."

"మరియు మార్గం ద్వారా, కోడ్ వేర్వేరు రంగులలో హైలైట్ చేయబడినప్పుడు, అర్థం చేసుకోవడం చాలా సులభం."