ఈ కథనం జావాలో వస్తువును కాపీ చేసే విధానాలను ప్రదర్శిస్తుంది.
జావాలో ఆబ్జెక్ట్‌ని ఎలా కాపీ చేయాలి?
కింది విధానాలను ఉపయోగించి ఒక వస్తువును జావాలో కాపీ చేయవచ్చు:
'లోని అన్ని తరగతులను యాక్సెస్ చేయండి java.util ఉదాహరణలకు వెళ్లే ముందు ప్యాకేజీ:
దిగుమతి జావా ఉపయోగపడుతుంది . *;
విధానం 1: “కాపీ కన్స్ట్రక్టర్” ఉపయోగించి జావాలో ఒక వస్తువును కాపీ చేయడం
ది ' కాపీ కన్స్ట్రక్టర్ ” గతంలో సృష్టించిన అదే తరగతి వస్తువును సూచించడం ద్వారా ఒక వస్తువును సృష్టిస్తుంది/నిర్వచిస్తుంది.
ఉదాహరణ
కింది ఉదాహరణ ఆబ్జెక్ట్‌ను కాపీ చేయడానికి “కాపీ కన్స్ట్రక్టర్”ని వర్తిస్తుంది:
ప్రజా తరగతి కాపీఆబ్జెక్ట్ {
int id ;
స్ట్రింగ్ నగరం ;
కాపీఆబ్జెక్ట్ ( int id , స్ట్రింగ్ నగరం ) {
ఇది . id = id ;
ఇది . నగరం = నగరం ; }
కాపీఆబ్జెక్ట్ ( కాపీ ఆబ్జెక్ట్ వస్తువు ) {
ఇది . id = వస్తువు. id ;
ఇది . నగరం = వస్తువు. నగరం ; }
ప్రజా శూన్యం ప్రదర్శన ( ) {
వ్యవస్థ. బయటకు . println ( 'ID ->' + ఇది . id ) ;
వ్యవస్థ. బయటకు . println ( 'నగరం ->' + ఇది . నగరం ) ; }
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
స్కానర్ ఇన్పుట్ = కొత్త స్కానర్ ( వ్యవస్థ. లో ) ;
వ్యవస్థ. బయటకు . println ( 'ఐడిని నమోదు చేయండి:' ) ;
int id = ఇన్పుట్. తదుపరిఇంట్ ( ) ;
వ్యవస్థ. బయటకు . println ( 'నగరంలోకి ప్రవేశించండి:' ) ;
స్ట్రింగ్ నగరం = ఇన్పుట్. తరువాత ( ) ;
కాపీఆబ్జెక్ట్ ఆబ్జెక్ట్1 = కొత్త కాపీఆబ్జెక్ట్ ( id , నగరం ) ;
కాపీఆబ్జెక్ట్ ఆబ్జెక్ట్2 = కొత్త కాపీఆబ్జెక్ట్ ( వస్తువు1 ) ;
వ్యవస్థ. బయటకు . println ( 'డిఫాల్ట్ ఆబ్జెక్ట్ ->' ) ;
వస్తువు1. ప్రదర్శన ( ) ;
వ్యవస్థ. బయటకు . println ( 'కాపీడ్ ఆబ్జెక్ట్ ->' ) ;
వస్తువు2. ప్రదర్శన ( ) ;
ఇన్పుట్. దగ్గరగా ( ) ;
} }
పై కోడ్ స్నిప్పెట్‌లో:
- ' పేరుతో తరగతిని సృష్టించండి కాపీఆబ్జెక్ట్ ”.
- క్లాస్‌లో పేర్కొన్న మెంబర్ వేరియబుల్స్‌ను పేర్కొనండి.
- ఆ తర్వాత, పేర్కొన్న వేరియబుల్స్‌కు పాస్ చేసిన విలువలను '' ద్వారా కేటాయించే పారామిటరైజ్డ్ క్లాస్ కన్‌స్ట్రక్టర్‌ను సృష్టించండి. ఇది ”.
- ఇప్పుడు, 'ని సృష్టించండి కాపీ కన్స్ట్రక్టర్ ” ఇది ఇప్పటికే సృష్టించబడిన క్లాస్ టైప్ ఆబ్జెక్ట్‌ని దాని పారామీటర్‌గా తీసుకుంటుంది, అది తర్వాత ఆర్గ్యుమెంట్‌గా పాస్ చేయబడుతుంది.
- అలాగే, ఫంక్షన్ నిర్వచించండి ' ప్రదర్శన() ” అది ఆమోదించబడిన వస్తువు విలువలను ప్రదర్శిస్తుంది.
- లో ' ప్రధాన () ” పద్ధతి, “ ద్వారా వినియోగదారు ఇన్‌పుట్‌ను అనుమతించడానికి “స్కానర్” ఆబ్జెక్ట్‌ను తయారు చేయండి System.in ”పరామితి.
- అలాగే, అనుబంధించండి ' nextInt() 'మరియు' తరువాత() ” వరుసగా పూర్ణాంకం మరియు స్ట్రింగ్ వినియోగదారు ఇన్‌పుట్‌లను తీసుకునే పద్ధతులు.
- '' ద్వారా తరగతి వస్తువును సృష్టించండి కొత్త 'కీవర్డ్ మరియు' కాపీఆబ్జెక్ట్() ” కన్స్ట్రక్టర్ వినియోగదారు ఇన్పుట్ విలువలను ఆర్గ్యుమెంట్‌లుగా కలిగి ఉంది.
- అలాగే, క్లాస్ కాపీ కన్‌స్ట్రక్టర్‌ను సూచించడం ద్వారా కాపీ చేసిన కంటెంట్‌లను తిరిగి ఇవ్వడానికి సృష్టించిన వస్తువును దాని వాదనగా కలిగి ఉన్న కాపీ ఆబ్జెక్ట్‌ను సృష్టించండి.
- చివరగా, 'ని పిలవండి ప్రదర్శన() పాస్ చేసిన వినియోగదారు ఇన్పుట్ విలువలను ప్రదర్శించడానికి మరియు 'స్కానర్'ని మూసివేయడానికి 'ఫంక్షన్.
అవుట్‌పుట్
ఈ అవుట్‌పుట్‌లో, కాపీ ఆబ్జెక్ట్ సృష్టించబడి, తదనుగుణంగా ప్రదర్శించబడుతుందని సూచించవచ్చు.
విధానం 2: “క్లోన్()” పద్ధతి ద్వారా జావాలో ఒక వస్తువును కాపీ చేయడం
ది ' క్లోన్ () 'పద్ధతి' java.lang.Object ” తరగతి ఒక వస్తువును పారామీటర్‌గా తీసుకుంటుంది, దాని కాపీని సృష్టిస్తుంది మరియు ఇస్తుంది. ఈ పద్ధతిని ఇప్పటికే సృష్టించిన వస్తువు (కాపీ చేయాల్సిన) మరియు “క్లోన్()” పద్ధతిని సూచించడం ద్వారా ఒక వస్తువును కాపీ చేయడానికి అమలు చేయవచ్చు.
వాక్యనిర్మాణం
వస్తువు. క్లోన్ ( )ఈ పద్ధతి వస్తువు యొక్క కాపీని ఇస్తుంది మరియు విసురుతాడు ' CloneNotSupportedException ”ఆబ్జెక్ట్ యొక్క క్లాస్ “క్లోనబుల్” ఇంటర్‌ఫేస్‌ను అమలు చేయకపోతే/వర్తించకపోతే.
ఉదాహరణ
కోడ్ యొక్క క్రింది పంక్తుల ద్వారా వెళ్ళండి:
int id ;
స్ట్రింగ్ నగరం ;
కాపీఆబ్జెక్ట్ ( int id , స్ట్రింగ్ నగరం ) {
ఇది . id = id ;
ఇది . నగరం = నగరం ;
}
ప్రజా శూన్యం ప్రదర్శన ( ) {
వ్యవస్థ. బయటకు . println ( 'ID ->' + ఇది . id ) ;
వ్యవస్థ. బయటకు . println ( 'నగరం ->' + ఇది . నగరం ) ;
}
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) విసురుతాడు CloneNotSupportedException {
స్కానర్ ఇన్పుట్ = కొత్త స్కానర్ ( వ్యవస్థ. లో ) ;
వ్యవస్థ. బయటకు . println ( 'ఐడిని నమోదు చేయండి:' ) ;
int id = ఇన్పుట్. తదుపరిఇంట్ ( ) ;
వ్యవస్థ. బయటకు . println ( 'నగరంలోకి ప్రవేశించండి:' ) ;
స్ట్రింగ్ నగరం = ఇన్పుట్. తరువాత ( ) ;
కాపీఆబ్జెక్ట్ ఆబ్జెక్ట్1 = కొత్త కాపీఆబ్జెక్ట్ ( id , నగరం ) ;
వ్యవస్థ. బయటకు . println ( 'డిఫాల్ట్ ఆబ్జెక్ట్ ->' ) ;
వస్తువు1. ప్రదర్శన ( ) ;
వ్యవస్థ. బయటకు . println ( 'కాపీడ్ ఆబ్జెక్ట్ ->' ) ;
కాపీఆబ్జెక్ట్ ఆబ్జెక్ట్2 = ( కాపీఆబ్జెక్ట్ ) వస్తువు1. క్లోన్ ( ) ;
వస్తువు2. ప్రదర్శన ( ) ;
ఇన్పుట్. దగ్గరగా ( ) ;
} }
పై కోడ్ బ్లాక్ ప్రకారం, దిగువ పేర్కొన్న దశలను చేయండి:
- క్లాస్‌ని నిర్వచించడం, మెంబర్ వేరియబుల్స్‌ని పేర్కొనడం, పారామిటరైజ్డ్ క్లాస్ కన్‌స్ట్రక్టర్‌ను సృష్టించడం (పాస్ చేసిన విలువలను కేటాయించడం) మరియు వరుసగా విలువలను ప్రదర్శించడానికి ఫంక్షన్‌ను నిర్వచించడం కోసం చర్చించిన విధానాలను గుర్తుకు తెచ్చుకోండి.
- ఇప్పుడు, 'లో ప్రధాన () ”, అదేవిధంగా, వినియోగదారు-ఇన్పుట్ విలువలను మరియు ఈ విలువలను సృష్టించిన క్లాస్ ఆబ్జెక్ట్‌కు పంపి, సంబంధిత ఫంక్షన్ ద్వారా వాటిని ప్రదర్శిస్తుంది.
- ఆ తరువాత, ' క్లోన్ () ” పద్ధతి అమలులోకి వస్తుంది, ఇది కాపీ ఆబ్జెక్ట్‌ను సృష్టించడానికి ఇప్పటికే సృష్టించబడిన వస్తువుతో అనుబంధించబడింది.
- చివరగా, చర్చించబడిన ఫంక్షన్ ద్వారా కాపీ చేయబడిన ఆబ్జెక్ట్ కంటెంట్‌లను ప్రదర్శించండి.
అవుట్‌పుట్
ఈ ఫలితంలో, వినియోగదారు ఇన్పుట్ విలువలు ఒకే విధమైన ఫలితాలతో రెండుసార్లు అందించబడి, క్లాస్ ఆబ్జెక్ట్ సముచితంగా కాపీ చేయబడిందని నిర్ధారిస్తుంది.
ముగింపు
ఒక వస్తువును జావాలో కాపీ చేయవచ్చు ' కాపీ కన్స్ట్రక్టర్ ', లేదా ' క్లోన్ () ” పద్ధతి. మునుపటి విధానం ఇప్పటికే సృష్టించబడిన వస్తువును కాపీ కన్స్ట్రక్టర్ వాదనగా తీసుకోవడం ద్వారా ఆబ్జెక్ట్‌ను కాపీ చేస్తుంది. తరువాతి విధానం సృష్టించబడిన తరగతి వస్తువుతో నేరుగా అనుబంధించబడింది. ఈ వ్రాత జావాలో ఒక వస్తువును కాపీ చేసే విధానాలను ప్రదర్శించింది.