"హాయ్, అమిగో!"
"హాయ్, కిమ్."
"నేను మీకు క్లోన్() పద్ధతి గురించి చెప్పబోతున్నాను."
"ఈ పద్ధతి యొక్క ఉద్దేశ్యం ఒక వస్తువును క్లోన్ చేయడం లేదా మరో మాటలో చెప్పాలంటే, వస్తువు యొక్క క్లోన్/కాపీ/నకిలీని సృష్టించడం."
"ఈ పద్ధతిని పిలిచినప్పుడు, జావా వర్చువల్ మెషీన్ అది పిలిచే వస్తువు యొక్క నకిలీని సృష్టిస్తుంది మరియు తిరిగి ఇస్తుంది.
ఆబ్జెక్ట్ క్లాస్ యొక్క క్లోన్ పద్ధతి యొక్క అమలు చాలా ప్రాచీనమైనది: ఒక కొత్త వస్తువు మాత్రమే సృష్టించబడుతుంది మరియు అసలు వస్తువు యొక్క ఫీల్డ్‌ల విలువలు దాని ఫీల్డ్‌లకు కేటాయించబడతాయి.
కాపీ చేయబడిన వస్తువు ఇతర వస్తువులకు సంబంధించిన సూచనలను కలిగి ఉంటే, ఆ సూచనలు కాపీ చేయబడతాయి. ఆ వస్తువుల నకిలీలు సృష్టించబడవు."
"హ్మ్మ్. అది చాలదు."
"విషయం ఏమిటంటే, జావా వర్చువల్ మెషీన్‌కు ఏ వస్తువులు క్లోన్ చేయవచ్చో లేదా క్లోన్ చేయలేదో తెలియదు. ఉదాహరణకు, ఫైల్‌లను క్లోన్ చేయడం సాధ్యం కాదు. System.in స్ట్రీమ్‌కి కూడా ఇది వర్తిస్తుంది."
"కాబట్టి, పూర్తి స్థాయి క్లోనింగ్ యొక్క ప్రశ్న ఒక తరగతి డెవలపర్‌లకు పంపబడింది. "ఇదంతా సమాన పద్ధతిని ఎలా నిర్వహించాలో అదే విధంగా ఉంటుంది. హ్యాష్‌కోడ్‌తో పోల్చదగినది కూడా ఉంది: క్లోన్ చేయదగిన ఇంటర్‌ఫేస్."
" క్లోన్ చేయదగిన ఇంటర్‌ఫేస్‌ని 'మార్కర్ ఇంటర్‌ఫేస్' అని పిలుస్తారు: దీనికి ఎటువంటి పద్ధతులు లేవు మరియు నిర్దిష్ట తరగతులను గుర్తించడానికి ఉపయోగించబడుతుంది.
"క్లాస్‌లోని వస్తువులను క్లోన్ చేయవచ్చని క్లాస్ డెవలపర్ విశ్వసిస్తే, అతను దానిని ఈ ఇంటర్‌ఫేస్‌తో మార్క్ చేస్తాడు (అంటే క్లాస్‌ని క్లోన్ చేయగలిగేలా చేస్తుంది)."
"డెవలపర్‌కు క్లోన్ పద్ధతి యొక్క ప్రామాణిక అమలు నచ్చకపోతే, అతను తన స్వంతంగా వ్రాయాలి, అది సరైన మార్గంలో నకిలీ వస్తువును సృష్టిస్తుంది."
"మీరు క్లోన్ () పద్ధతికి కాల్ చేసినప్పుడు , ఆబ్జెక్ట్ క్లోన్ చేయదగిన ఇంటర్‌ఫేస్‌కు మద్దతిస్తుందో లేదో జావా తనిఖీ చేస్తుంది. అలా చేస్తే, అది క్లోన్ ( ) పద్ధతిని ఉపయోగించి ఆబ్జెక్ట్‌ను క్లోన్ చేస్తుంది; కాకపోతే, అది క్లోన్‌నాట్‌సపోర్టెడ్ ఎక్సెప్షన్‌ను విసురుతుంది."
"మరో మాటలో చెప్పాలంటే, మనం క్లోన్ పద్ధతిని భర్తీ చేయాలి లేదా క్లాస్‌ని క్లోన్ చేయదగినదిగా అమలు చేయాలి?"
"అవును, కానీ మీరు ఇప్పటికీ పద్ధతిని భర్తీ చేయాలి. క్లోన్() పద్ధతి రక్షితమైనదిగా ప్రకటించబడింది, కనుక ఇది దాని ప్యాకేజీ (java.lang.*) లేదా వాటి ఉపవర్గాల ద్వారా మాత్రమే పిలువబడుతుంది."
"నేను కొంచెం గందరగోళంగా ఉన్నాను-కాబట్టి నేను ఒక వస్తువును క్లోన్ చేయడానికి ఏమి చేయాలి?"
"మీరు ఆబ్జెక్ట్ క్లాస్ యొక్క «డిఫాల్ట్» క్లోనింగ్ పద్ధతిని ఉపయోగించాలనుకుంటే, మీరు వీటిని చేయాలి:
" ఎ) మీ తరగతికి క్లోన్ చేయదగిన ఇంటర్‌ఫేస్‌ను జోడించండి"
" బి) క్లోన్ పద్ధతిని భర్తీ చేయండి మరియు మీ అమలులో సూపర్‌క్లాస్ అమలుకు కాల్ చేయండి:"
class Point implements Cloneable
{
int x;
int y;
public Object clone()
{
return super.clone();
}
}"లేదా మీరు పూర్తిగా మీ స్వంతంగా క్లోన్ పద్ధతి యొక్క అమలును వ్రాయవచ్చు:"
class Point
{
int x;
int y;
public Object clone()
{
Point point = new Point();
point.x = this.x;
point.y = this.y;
return point;
}
}"అదొక ఆసక్తికరమైన పద్ధతి. నేను ఖచ్చితంగా దాన్ని ఉపయోగిస్తాను. అప్పుడప్పుడు..."
GO TO FULL VERSION