జెనరిక్స్ అంటే ఏమిటి?

"మరో కూల్ టాపిక్."

"ఆశ్చర్యాలు వస్తూనే ఉన్నాయి! నా పుట్టినరోజునా?"

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

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

"అరేలిస్ట్ ఒక మంచి ఉదాహరణ. మేము కొత్త అర్రేలిస్ట్ ఆబ్జెక్ట్‌ను సృష్టించినప్పుడు, ఈ జాబితాలో నిల్వ చేయబడే విలువల రకాన్ని సూచించడం సౌకర్యంగా ఉంటుంది."

ArrayList<String> list = new ArrayList<String>();

ArrayList list = new ArrayList();

ArrayList<Integer> list = new ArrayList<Integer>();

"చాలా ఆసక్తికరంగా ఉంది. ముఖ్యంగా ఏ రకం విలువలను నిల్వ చేయడం గురించిన భాగం ."

"ఇది మంచి విషయమని మాత్రమే అనిపిస్తుంది. వాస్తవానికి, మేము ఒక పద్ధతిలో శ్రేణుల జాబితాలో స్ట్రింగ్‌లను ఉంచి, మరొక పద్ధతిలో సంఖ్యలను కలిగి ఉండాలని ఆశించినట్లయితే, ప్రోగ్రామ్ క్రాష్ అవుతుంది (లోపంతో ముగుస్తుంది)."

"అలాగా."

"ప్రస్తుతానికి, మేము టైప్ పారామితులతో మా స్వంత తరగతులను సృష్టించము . మేము ఇప్పటికే ఉన్న వాటిని ఉపయోగిస్తాము."

"ఏదైనా క్లాస్ టైప్ పారామీటర్ అయి ఉంటుందా, నేను వ్రాసేది కూడా?"

"అవును. ఆదిమ రకాలు మినహా ఏదైనా రకం. అన్ని రకాల పారామితులు తప్పనిసరిగా ఆబ్జెక్ట్ క్లాస్ నుండి పొందాలి."

" అంటే నేను అర్రేలిస్ట్<int> ని వ్రాయలేనని ? "

"నిజానికి, మీరు చేయలేరు. కానీ జావా డెవలపర్‌లు ప్రతి ఆదిమ రకాలకు రేపర్ తరగతులను వ్రాసారు. ఈ తరగతులు ఆబ్జెక్ట్‌ను వారసత్వంగా పొందుతాయి . ఇది ఇలా కనిపిస్తుంది:"

"మీరు ఆదిమ తరగతులను మరియు వాటి అనలాగ్‌లను (ర్యాపర్ తరగతులు) ఒకదానికొకటి సులభంగా కేటాయించవచ్చు:"

int a = 5;
Integer b = a;
int c = b;

Character c = 'c';  //the literal c is a char
char d = c;

Byte b = (byte) 77;  // The literal 77 is an int

Boolean isOk = true;  // the literal true is a boolean

Double d = 1.0d;  // The literal 1.0d is a double

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