1. అన్ని తరగతులు వారసత్వంగాObject
జావాలోని అన్ని తరగతులు అంతర్లీనంగా Object
తరగతిని వారసత్వంగా పొందుతాయి.
మేము జావా కోర్ అన్వేషణలో జావాలో వారసత్వం అంటే ఏమిటి మరియు అది ఎలా పని చేస్తుందో విశ్లేషిస్తాము. ప్రస్తుతానికి, మేము దీని నుండి అనుసరించే ఒక సాధారణ వాస్తవాన్ని పరిశీలిస్తాము:
ఏదైనా తరగతికి చెందిన వస్తువును వేరియబుల్కు కేటాయించవచ్చు Object
. ఉదాహరణ:
కోడ్ | గమనిక |
---|---|
|
వేరియబుల్ ఒక వస్తువుకు o సూచనను నిల్వ చేస్తుందిScanner |
|
వేరియబుల్ ఒక వస్తువుకు o సూచనను నిల్వ చేస్తుందిString |
|
వేరియబుల్ ఒక వస్తువుకు o సూచనను నిల్వ చేస్తుందిInteger |
|
వేరియబుల్ ఒక వస్తువుకు o సూచనను నిల్వ చేస్తుందిString |
ఇక్కడే శుభవార్త ముగుస్తుంది. కంపైలర్ వేరియబుల్లో సేవ్ చేయబడిన అసలు రకం ఆబ్జెక్ట్ను ట్రాక్ చేయదుObject
, కాబట్టి మీరు సేవ్ చేసిన ఆబ్జెక్ట్పై క్లాస్ యొక్క పద్ధతులు కాకుండా ఇతర పద్ధతులను కాల్ చేయలేరు .Object
మీరు ఆబ్జెక్ట్ యొక్క అసలైన రకంతో అనుబంధించబడిన పద్ధతులను కాల్ చేయవలసి వస్తే, మీరు ముందుగా దానికి సంబంధించిన సూచనను సరైన రకం యొక్క వేరియబుల్లో సేవ్ చేయాలి, ఆపై ఆ వేరియబుల్లోని పద్ధతులను కాల్ చేయండి:
కోడ్ | గమనిక |
---|---|
|
ప్రోగ్రామ్ కంపైల్ చేయదు. తరగతికి పద్ధతి Object లేదు nextInt() . |
|
ఇది పని చేస్తుంది. ఇక్కడ మనం టైప్కాస్ట్ ఆపరేటర్ని ఉపయోగించి వేరియబుల్లో ఆబ్జెక్ట్కు సూచనను సేవ్ చేస్తాము . Scanner Scanner |
వేరియబుల్ రిఫరెన్స్ ఆబ్జెక్ట్ను స్టోర్ చేసినప్పటికీ Object
, మీరు కేవలం వెళ్లి స్కానర్ వేరియబుల్కు వేరియబుల్ను కేటాయించలేరు . Object
Scanner
కానీ మీరు టైప్కాస్ట్ ఆపరేటర్ని ఉపయోగిస్తే మీరు దీన్ని చేయవచ్చు , ఇది మీకు ఇప్పటికే తెలుసు. ఇది దాని సాధారణ రూపం:
Type name1 = (Type) name2;
name1
వేరియబుల్ పేరు ఎక్కడ ఉంది Type
మరియు ఒక వస్తువుకు సూచనను నిల్వ చేసే వేరియబుల్ name2
పేరు .Object
Type
టైప్ కాస్టింగ్
వేరియబుల్ రకం మరియు ఆబ్జెక్ట్ రకం సరిపోలకపోతే, అప్పుడు a ClassCastException
విసిరివేయబడుతుంది. ఉదాహరణ:
కోడ్ | గమనిక |
---|---|
|
రన్టైమ్లో ఎర్రర్ ఏర్పడుతుంది: a ClassCastException ఇక్కడ విసిరివేయబడుతుంది |
జావాలో ఈ లోపాన్ని నివారించడానికి ఒక మార్గం ఉంది: వేరియబుల్లో నిల్వ చేయబడిన వస్తువు యొక్క రకాన్ని తనిఖీ చేయడం ద్వారా మేము దీన్ని చేస్తాము :
name instanceof Type
ఆపరేటర్ వేరియబుల్ ఒక వస్తువు instanceof
కాదా అని తనిఖీ చేస్తుంది .name
Type
ఉదాహరణగా, విభిన్న వస్తువుల శ్రేణిలో స్ట్రింగ్ను కనుగొనండి:
కోడ్ | గమనిక |
---|---|
|
ఆటోబాక్సింగ్ ఈ విలువలను వరుసగా ఒక Integer , String , మరియు , గా మారుస్తుంది . ఆబ్జెక్ట్ల శ్రేణిపై లూప్ చేయండి ఆబ్జెక్ట్ ఒక వేరియబుల్ అయితే దాన్ని వేరియబుల్కు సేవ్ చేయండి స్క్రీన్పై వేరియబుల్ని ప్రదర్శించండి. Double String String |
2. జెనరిక్స్ ఎందుకు కనిపించాయి - సేకరణలు
సేకరణలకు తిరిగి వద్దాం.
జావా డెవలపర్లు తరగతిని సృష్టించిన వెంటనే ArrayList
, వారు దానిని విశ్వవ్యాప్తం చేయాలని కోరుకున్నారు, కనుక ఇది ఏ రకమైన వస్తువునైనా నిల్వ చేయగలదు. Object
కాబట్టి వారు మూలకాలను నిల్వ చేయడానికి s యొక్క శ్రేణిని ఉపయోగించారు .
ఈ విధానం యొక్క బలం ఏమిటంటే మీరు సేకరణకు ఏ రకమైన వస్తువునైనా జోడించవచ్చు.
వాస్తవానికి, అనేక బలహీనతలు ఉన్నాయి.
ప్రతికూలత 1.
సేకరణ నుండి మూలకాలను తిరిగి పొందేటప్పుడు టైప్ కన్వర్షన్ ఆపరేటర్ని వ్రాయడం ఎల్లప్పుడూ అవసరం:
కోడ్ | గమనిక |
---|---|
|
Object వస్తువులకు సూచనలను నిల్వ చేయడానికి సేకరణను సృష్టించండి, సంఖ్యలతో సేకరణను పూరించండి 10 , 20 ... 100 ; సేకరణ మూలకాల మొత్తం టైప్కాస్టింగ్ అవసరం |
ప్రతికూలత 2.
సేకరణలో నిర్దిష్ట రకం మూలకం ఉందని ఎటువంటి హామీ లేదు
కోడ్ | గమనిక |
---|---|
|
Object వస్తువులకు సూచనలను నిల్వ చేయడానికి సేకరణను సృష్టించండి మేము ఆబ్జెక్ట్లుగా సూచించబడే సంఖ్యలతో సేకరణను నింపుతాము : , , , ... సేకరణలోని మూలకాల మొత్తాన్ని ఒక లోపం ఏర్పడుతుంది: a కు ప్రసారం చేయడం సాధ్యం కాదు Double 0.0 2.5 5.0 Double Integer |
డేటాను ఎక్కడైనా సేకరణలో ఉంచవచ్చు:
- మరొక పద్ధతిలో
- మరొక కార్యక్రమంలో
- ఒక ఫైల్ నుండి
- నెట్వర్క్ ద్వారా
ప్రతికూలత 3.
సేకరణలోని డేటా అనుకోకుండా మార్చబడుతుంది.
మీరు మీ డేటాతో నిండిన సేకరణను ఏదో ఒక పద్ధతికి పంపవచ్చు. వేరొక ప్రోగ్రామర్ వ్రాసిన ఆ పద్ధతి దాని డేటాను మీ సేకరణకు జోడిస్తుంది.
సేకరణ పేరు దానిలో ఏ రకమైన డేటాను నిల్వ చేయవచ్చో స్పష్టంగా సూచించలేదు. మరియు మీరు మీ వేరియబుల్కు స్పష్టమైన పేరు ఇచ్చినప్పటికీ, దాని సూచనను డజను పద్ధతులకు పంపవచ్చు మరియు ఆ పద్ధతులకు ఖచ్చితంగా వేరియబుల్ యొక్క అసలు పేరు గురించి ఏమీ తెలియదు.
3. జెనరిక్స్
జావాలో, ఈ సమస్యలన్నీ జెనరిక్స్ అనే చక్కని విషయం ద్వారా తొలగించబడతాయి.
జావాలో, జెనరిక్స్ అంటే టైప్ పారామితులను టైప్లకు జోడించే సామర్థ్యం. ఫలితం సంక్లిష్టమైన మిశ్రమ రకం. అటువంటి మిశ్రమ రకం యొక్క సాధారణ వీక్షణ ఇది:
ClassName<TypeParameter>
ఇది సాధారణ తరగతి. మరియు మీరు సాధారణంగా తరగతులను ఉపయోగించే చోట దీనిని ఉపయోగించవచ్చు.
కోడ్ | వివరణ |
---|---|
|
వేరియబుల్స్ సృష్టిస్తోంది |
|
వస్తువులను సృష్టించడం |
|
శ్రేణులను సృష్టిస్తోంది |
Integer
అటువంటి సేకరణలో వేరియబుల్స్ మాత్రమే నిల్వ చేయబడతాయి:
కోడ్ | వివరణ |
---|---|
|
ArrayList Integer మూలకాలతో సేకరణ ఇది అనుమతించబడుతుంది మరియు ఇది కూడా పని చేస్తుంది
ఆటోబాక్సింగ్
కానీ ఇది అనుమతించబడదు: సంకలనం లోపం |
జావా కలెక్షన్స్ క్వెస్ట్లో టైప్ పారామితులతో మీ స్వంత తరగతులను ఎలా సృష్టించాలో మీరు నేర్చుకుంటారు. ప్రస్తుతానికి, మేము వాటిని ఎలా ఉపయోగించాలో మరియు అవి ఎలా పని చేస్తాయో చూద్దాం.
4. జెనరిక్స్ ఎలా పని చేస్తాయి
నిజానికి, జెనరిక్స్ చాలా ప్రాచీనమైనవి.
కంపైలర్ సాధారణ రకాలను సాధారణ రకాలతో భర్తీ చేస్తుంది. కానీ సాధారణ రకం పద్ధతులను ఉపయోగించినప్పుడు, కంపైలర్ టైప్ పారామితులకు పారామితులను ప్రసారం చేయడానికి టైప్కాస్ట్ ఆపరేటర్ను జోడిస్తుంది:
కోడ్ | కంపైలర్ ఏమి చేస్తుంది |
---|---|
|
|
|
|
|
|
|
|
పూర్ణాంకాల సేకరణలో సంఖ్యలను సంక్షిప్తీకరించే పద్ధతిని కలిగి ఉన్నారని అనుకుందాం:
కోడ్ | కంపైలర్ ఏమి చేస్తుంది |
---|---|
|
|
మరో మాటలో చెప్పాలంటే, జెనరిక్స్ అనేది ఆటోబాక్సింగ్ లాగా ఒక రకమైన వాక్యనిర్మాణ చక్కెర, కానీ కొంచెం ఎక్కువ. int
ఆటోబాక్సింగ్తో, కంపైలర్ aని ఒకకి మార్చడానికి పద్ధతులను జోడిస్తుంది Integer
మరియు దీనికి విరుద్ధంగా, మరియు జెనరిక్స్ కోసం ఇది టైప్కాస్ట్ ఆపరేటర్లను జోడిస్తుంది.
కంపైలర్ మీ సాధారణ తరగతులను టైప్ పారామితులతో కంపైల్ చేసిన తర్వాత, అవి సాధారణ తరగతులు మరియు టైప్కాస్ట్ ఆపరేటర్లుగా మార్చబడతాయి. జెనరిక్ రకాల వేరియబుల్స్కు పంపబడిన టైప్ ఆర్గ్యుమెంట్ల గురించిన సమాచారం పోతుంది. ఈ ప్రభావాన్ని టైప్ ఎరేజర్ అని కూడా అంటారు .
కొన్నిసార్లు సాధారణ తరగతులు (రకం పారామితులు కలిగిన తరగతులు) వ్రాసే ప్రోగ్రామర్లకు ఆర్గ్యుమెంట్లుగా ఆమోదించబడిన రకాల గురించి నిజంగా సమాచారం అవసరం. జావా కలెక్షన్స్ అన్వేషణలో, మీరు దీన్ని ఎలా ఎదుర్కోవాలో మరియు దానితో ఏమి చేయాలో నేర్చుకుంటారు.
5. జెనరిక్స్ గురించి కొన్ని వాస్తవాలు
జెనరిక్స్ గురించి మరికొన్ని ఆసక్తికరమైన విషయాలు ఇక్కడ ఉన్నాయి.
తరగతులు అనేక రకాల పారామితులను కలిగి ఉంటాయి. ఇది ఇలా కనిపిస్తుంది:
ClassName<TypeParameter1, TypeParameter2, TypeParameter3>
నిజానికి, ఇది నిజంగా ఆశ్చర్యం కలిగించదు. ఎక్కడైనా కంపైలర్ ఒక రకానికి ప్రసారం చేయడానికి ఆపరేటర్ని జోడించవచ్చు, అది బహుళ టైప్కాస్ట్ ఆపరేటర్లను జోడించగలదు.
ఉదాహరణలు:
కోడ్ | గమనిక |
---|---|
|
పద్ధతి put యొక్క మొదటి పరామితి a Integer , మరియు రెండవది aString |
సాధారణ రకాలను పారామీటర్లుగా కూడా ఉపయోగించవచ్చు . ఇది ఇలా కనిపిస్తుంది:
ClassName<TypeParameter<TypeParameterParameter>>
మేము స్ట్రింగ్ల జాబితాలను నిల్వ చేసే జాబితాను సృష్టించాలనుకుంటున్నాము. ఈ సందర్భంలో, మేము ఇలాంటివి పొందుతాము:
// List of greetings
ArrayList<String> listHello = new ArrayList<String>();
listHello.add ("Hello");
listHello.add ("Hi");
// List of goodbyes
ArrayList<String> listBye = new ArrayList<String>();
listBye.add("Bye");
listBye.add ("Goodbye");
// List of lists
ArrayList<ArrayList<String>> lists = new ArrayList<ArrayList<String>>();
lists.add(listHello);
lists.add(listBye);
సాధారణ రకాలు (రకం పారామితులతో రకాలు) శ్రేణి రకాలుగా కూడా ఉపయోగించవచ్చు. ఇది ఇలా కనిపిస్తుంది:
ClassName<TypeParameter>[] array = new ClassName<TypeParameter>[size];
ఇక్కడ అద్భుతంగా ఏమీ జరగలేదు: యాంగిల్ బ్రాకెట్లు రకం పేరును సూచిస్తాయి:
కోడ్ | నాన్-జెనరిక్ ప్రతిరూపం |
---|---|
|
|
|
|
|
|