"హాయ్, అమిగో!"
"హాయ్, బిలాబో!"
"ఈ రోజు బిలాబో మీకు మార్చగల మరియు మారని వస్తువుల గురించి చెబుతుంది .
"అవి సృష్టించబడిన తర్వాత మీరు మార్చగల వస్తువులను మార్చదగినవి అంటారు . "
"సృష్టించిన తర్వాత మార్చలేని వస్తువులను మార్పులేనివి అంటారు . "
"నేను ఒక వస్తువును మార్చగలనా అని ఏది నిర్ణయిస్తుంది?"
"కొత్త తరగతి యొక్క రచయిత ఆ తరగతిలోని వస్తువులను మార్పులేనిదిగా చేయగలడు. ఉదాహరణకు, మీరు సెట్టర్‌లన్నింటినీ ప్రైవేట్‌గా చేస్తే, ఆ వస్తువుకు కన్స్ట్రక్టర్ మరియు గెటర్‌లు మాత్రమే ఉంటాయి; అంటే దానిని సృష్టించిన తర్వాత మార్చడం అసాధ్యం. ."
"మరియు దాని ప్రయోజనం ఏమిటి?"
"మార్పులేని వస్తువులు చాలా ఉపయోగకరమైన లక్షణాలను కలిగి ఉంటాయి, కానీ దాదాపు అన్ని మార్పులేని వస్తువులకు సాధారణమైన రెండింటిని నేను హైలైట్ చేస్తాను:"
1) మార్చలేని వస్తువుల కంటే మార్చలేని వస్తువులు అమలు చేయడం చాలా సులభం.
2) మారని వస్తువులను ఏకకాలంలో బహుళ థ్రెడ్‌లలో ఉచితంగా ఉపయోగించవచ్చు.
"ఒక డెవలపర్ ఒక మార్పులేని తరగతిని వ్రాయాలని నిర్ణయించుకున్నప్పుడు, అతను సాధారణంగా తరగతి యొక్క మార్చదగిన మరియు మార్పులేని వెర్షన్ రెండింటినీ తయారు చేస్తాడు."
"అయితే ఒకటికి బదులు రెండు తరగతులు రాయడం ఏమిటి?"
"కొన్నిసార్లు ఒక వస్తువు యొక్క మార్పులేని సంస్కరణ మార్చగల దానికంటే చాలా సరళమైనది/వేగంగా ఉన్నప్పుడు అది విలువైనది. కాబట్టి, అవి రెండు వెర్షన్‌లను తయారు చేస్తాయి. ఇది అర్రేలిస్ట్ మరియు లింక్డ్‌లిస్ట్ లాంటిది: రెండూ జాబితాలు, కానీ ఒకటి నిర్దిష్ట ప్రయోజనాల కోసం ఆప్టిమైజ్ చేయబడింది, మరియు రెండవది ఇతరులకు."
"ఇది ఇప్పటికే మరింత అర్ధమే."
"పూర్తిగా మార్పులేని తరగతులు కూడా ఉన్నాయి, వాటికి మార్చదగిన సంస్కరణ లేదు."
"అయితే నేను ఆ వస్తువులలో ఏదో ఒకదానిలో ఏదైనా మార్చవలసి వస్తే? మార్పులేని వస్తువుతో మీరు నిజంగా ఏమి చేయగలరు?"
"సాధారణంగా, మార్పులేని తరగతులు ఆబ్జెక్ట్‌ను మార్చినట్లుగా పని చేసే వివిధ పద్ధతులను కలిగి ఉంటాయి, అయితే ఈ పద్ధతులు కేవలం వస్తువును మార్చే బదులు కొత్త వస్తువును సృష్టించి, దానిని తిరిగి ఇచ్చేస్తాయి."
"ఇవి కొన్ని ఉదాహరణలు:"
| జావా కోడ్ | వివరణ |
|---|---|
|
ఫలితంగా, s స్ట్రింగ్ «లండన్» మరియు s2 «లండన్» కలిగి ఉంటుంది |
|
ఇక్కడ నిజంగా ఏమి జరుగుతుంది: పూర్ణాంకం i = కొత్త పూర్ణాంకం(1); పూర్ణాంకం j = i; j = కొత్త పూర్ణాంకం(i.getInt()+1); |
"స్ట్రింగ్ క్లాస్ అనేది మార్పులేని తరగతి. అన్ని స్ట్రింగ్ ఆబ్జెక్ట్‌లు మార్పులేనివి, కానీ అది వాటితో పని చేయకుండా మనల్ని నిరోధించదు. ఉదాహరణకు, స్ట్రింగ్ క్లాస్ యొక్క toUpperCase () పద్ధతి స్ట్రింగ్‌ను పెద్ద అక్షరానికి మారుస్తుంది (అంటే అన్ని చిన్న అక్షరాలను భర్తీ చేస్తుంది పెద్ద అక్షరాలతో) అయితే, ఈ పద్ధతి స్ట్రింగ్‌ను మార్చదు, బదులుగా ఇది కొత్త స్ట్రింగ్‌ను అందిస్తుంది. ఈ కొత్త స్ట్రింగ్ అన్ని అక్షరాలు పెద్ద అక్షరాలు (పెద్ద అక్షరాలు) తప్ప మొదటి దానికి సమానంగా ఉంటుంది."
"పూర్ణాంక తరగతి కూడా మార్పులేని తరగతి. అన్ని పూర్ణాంక వస్తువులు మార్పులేనివి. మనం పూర్ణాంక వస్తువును మార్చిన ప్రతిసారీ, వాస్తవానికి మనం కొత్త వస్తువును సృష్టిస్తున్నాము."
"ఎంత ఆసక్తికరంగా! హుర్రే, బిలాబో."
"నాకు హుర్రే! బిలాబోకు హుర్రే!"
GO TO FULL VERSION