జావాలో ఒక వస్తువు యొక్క రకాన్ని పొందే పద్ధతిని తెలుసుకోవడానికి ఈ కథనం మీకు సహాయం చేస్తుంది.
జావాలో ఆబ్జెక్ట్ రకాన్ని ఎలా పొందాలి?
జావాలో ముందే నిర్వచించబడిన లేదా వినియోగదారు నిర్వచించిన తరగతి వస్తువు యొక్క రకాన్ని పొందడానికి, మీరు వీటిని ఉపయోగించవచ్చు:
- getClass() పద్ధతి
- ఉదాహరణ ఆపరేటర్
మేము ఇప్పుడు పేర్కొన్న ప్రతి పద్ధతులను ఒక్కొక్కటిగా తనిఖీ చేస్తాము!
విధానం 1: getClass() పద్ధతిని ఉపయోగించి ముందే నిర్వచించబడిన తరగతి వస్తువు యొక్క రకాన్ని పొందండి
జావాలో, మేము స్ట్రింగ్, డబుల్, పూర్ణాంకం మరియు మరెన్నో వంటి రేపర్ క్లాస్‌ల వంటి ముందే నిర్వచించిన తరగతులను కలిగి ఉన్నాము. ముందే నిర్వచించిన తరగతులను ఉపయోగిస్తున్నప్పుడు కొన్నిసార్లు మనం ఆబ్జెక్ట్ రకాన్ని ధృవీకరించాలి. ఈ ప్రయోజనం కోసం, జావా అందిస్తుంది “ getClass() 'పద్ధతి'కి చెందినది వస్తువు ” తరగతి.
వాక్యనిర్మాణం
యొక్క వాక్యనిర్మాణం ' getClass() 'పద్ధతి క్రింది విధంగా ఇవ్వబడింది:
x getClass ( )
ఇక్కడ, ' getClass() 'పద్ధతి పేర్కొన్న తరగతిని అందిస్తుంది' x ” వస్తువు.
ఉదాహరణ
ఈ ఉదాహరణలో, మేము '' అనే స్ట్రింగ్ టైప్ ఆబ్జెక్ట్‌ని సృష్టిస్తాము. x ' కింది విలువను కలిగి ఉంది:
స్ట్రింగ్ x = 'హలో' ;
తరువాత, మేము “ని ఉపయోగించి స్టేట్‌మెంట్‌ను ప్రింట్ చేస్తాము System.out.println() 'పద్ధతి:
వ్యవస్థ . బయటకు . println ( 'x చెందినది?' ) ;చివరగా, మేము వస్తువు యొక్క రకాన్ని పొందుతాము ' x '' అని పిలవడం ద్వారా getClass() 'పద్ధతి:
వ్యవస్థ . బయటకు . ముద్రణ ( x getClass ( ) ) ;సృష్టించబడిన వేరియబుల్ జావా స్ట్రింగ్ క్లాస్‌కు చెందినదని అవుట్‌పుట్ చూపిస్తుంది:
'instanceof' ఆపరేటర్‌ని ఉపయోగించి ఆబ్జెక్ట్ రకాన్ని పొందడానికి మరొక పద్ధతిని చూద్దాం.
విధానం 2: 'ఉదాహరణ' ఆపరేటర్‌ని ఉపయోగించి ముందే నిర్వచించబడిన క్లాస్ ఆబ్జెక్ట్ రకాన్ని పొందండి
మీరు కూడా ఉపయోగించవచ్చు ' ఉదాహరణ ” జావా ప్రోగ్రామ్‌లో ఆబ్జెక్ట్ రకాన్ని తనిఖీ చేయడానికి ఆపరేటర్. ఈ ఆపరేటర్ బూలియన్ విలువను అందిస్తుంది, ఇది ఆబ్జెక్ట్ నిర్దిష్ట తరగతికి సంబంధించినదా కాదా అని సూచిస్తుంది.
వాక్యనిర్మాణం
యొక్క వాక్యనిర్మాణం ' ఉదాహరణ ” ఈ క్రింది విధంగా ఉంది:
ఇక్కడ, ' x 'ఒక వస్తువు మరియు' పూర్ణ సంఖ్య ” అనేది ముందే నిర్వచించబడిన జావా రేపర్ క్లాస్. ది ' ఉదాహరణ ” ఆపరేటర్ ఆబ్జెక్ట్ పేర్కొన్న తరగతికి చెందినదా కాదా అని తనిఖీ చేస్తుంది మరియు బూలియన్ విలువను అందిస్తుంది.
ఉదాహరణ
ఈ ఉదాహరణలో, మనకు ఒక వస్తువు ఉంది ' x 'పూర్ణాంక తరగతి కలిగి' 5 'దాని విలువగా:
తరువాత, మేము “ని ఉపయోగించి స్టేట్‌మెంట్‌ను ప్రింట్ చేస్తాము System.out.println() 'పద్ధతి:
వ్యవస్థ . బయటకు . ముద్రణ ( 'x అనేది పూర్ణాంక తరగతికి ఉదాహరణ?' ) ;ఇప్పుడు, ఆబ్జెక్ట్ పూర్ణాంక తరగతికి ఉదాహరణ కాదా అని మేము తనిఖీ చేస్తాము:
వ్యవస్థ . బయటకు . ముద్రణ ( x ఉదాహరణ పూర్ణ సంఖ్య ) ; 
అవుట్‌పుట్ ప్రదర్శించబడుతుంది ' నిజం 'వస్తువుగా' x ” అనేది పూర్ణాంక తరగతికి ఉదాహరణ:
ఈ సమయంలో, మీరు వినియోగదారు నిర్వచించిన తరగతి వస్తువు యొక్క రకాన్ని ఎలా పొందాలనే దాని గురించి ఆలోచిస్తూ ఉండవచ్చు. దిగువ ఇవ్వబడిన విభాగం ఈ విషయంలో మీకు సహాయం చేస్తుంది.
విధానం 3: getClass() పద్ధతిని ఉపయోగించి వినియోగదారు నిర్వచించిన క్లాస్ ఆబ్జెక్ట్ రకాన్ని పొందండి
మీరు '' సహాయంతో వినియోగదారు నిర్వచించిన తరగతి వస్తువు యొక్క రకాన్ని కూడా పొందవచ్చు getClass() ” పద్ధతి. అటువంటి దృష్టాంతంలో, మేము ఆబ్జెక్ట్‌ని తరగతి పేరుతో పోల్చి చూస్తాము “ == ” పోలిక ఆపరేటర్.
వాక్యనిర్మాణం
పేర్కొన్న ప్రయోజనం కోసం, వాక్యనిర్మాణం “ getClass() ” పద్ధతి ఇలా ఇవ్వబడింది:
ఇక్కడ, ' getClass() 'పద్ధతిని' అంటారు myclassObj 'వస్తువు' నా తరగతి ” ఆపై కంపారిజన్ ఆపరేటర్‌ని ఉపయోగించి పేరుతో పోల్చబడింది “ == ”.
ఉదాహరణ
ఈ ఉదాహరణలో, మనకు '' అనే మూడు తరగతులు ఉన్నాయి. నా తరగతి ',' MynewClass ', మరియు' ఉదాహరణ ”, ఇక్కడ MyClass MynewClass యొక్క పేరెంట్ క్లాస్‌గా పనిచేస్తుంది:
ది ' MynewClass 'ఇది పిల్లల తరగతి' నుండి విస్తరించబడింది నా తరగతి ”:
తరగతి MynewClass విస్తరించింది నా తరగతి { }తరగతి యొక్క ప్రధాన () పద్ధతిలో ' ఉదాహరణ ', మేము మాతృ తరగతి యొక్క వస్తువును ప్రకటిస్తాము మరియు తక్షణమే చేస్తాము' నా తరగతి ”. అప్పుడు సృష్టించబడిన వస్తువు ఏ తరగతికి చెందినదో తనిఖీ చేయండి; తల్లిదండ్రులు లేదా బిడ్డ? అలా చేయడానికి, మేము '' అని పిలుస్తాము getClass() 'సృష్టించబడిన ఆబ్జెక్ట్‌తో పద్ధతి మరియు ఫలిత విలువను ఉంటే-else-if షరతులను ఉపయోగించి తల్లిదండ్రులు మరియు పిల్లల తరగతి పేర్లతో సరిపోల్చండి:
ప్రజా తరగతి ఉదాహరణ {ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
MyClass myclassObj = కొత్త నా తరగతి ( ) ;
ఉంటే ( myclassObj. getClass ( ) == నా తరగతి. తరగతి ) {
వ్యవస్థ . బయటకు . println ( 'ఆబ్జెక్ట్ 'myclassObj' అనేది 'MyClass' రకం' ) ;
} లేకపోతే ఉంటే ( myclassObj. getClass ( ) == MynewClass. తరగతి ) {
వ్యవస్థ . బయటకు . println ( ''myclassObj' వస్తువు 'MynewClass' రకం' ) ;
}
}
}
అవుట్‌పుట్ ఆబ్జెక్ట్ ' అని సూచిస్తుంది myclassObj 'పేరెంట్ క్లాస్‌కి చెందినది' నా తరగతి ”:
ఇప్పుడు, తదుపరి విభాగం వైపు వెళ్ళండి!
విధానం 4: 'ఉదాహరణ' ఆపరేటర్‌ని ఉపయోగించి వినియోగదారు నిర్వచించిన క్లాస్ ఆబ్జెక్ట్ రకాన్ని పొందండి
ముందే నిర్వచించిన తరగతుల మాదిరిగానే, వినియోగదారు నిర్వచించిన తరగతుల కోసం, మీరు “ని ఉపయోగించడం ద్వారా ఆబ్జెక్ట్ రకాన్ని కూడా పొందవచ్చు. ఉదాహరణ ” ఆపరేటర్.
వాక్యనిర్మాణం
వాక్యనిర్మాణం క్రింద ఇవ్వబడింది:
ఇక్కడ, ' ఉదాహరణ 'ఆపరేటర్ తనిఖీ చేస్తుంది' myclassObj 'ఒక ఉదాహరణ' నా తరగతి ” లేదా.
ఉదాహరణ
మేము ఇంతకు ముందు పేర్కొన్న ఉదాహరణలో సృష్టించిన తరగతులనే ఇప్పుడు ఉపయోగిస్తాము. ఒకే తేడా ఏమిటంటే, మేము 'ని ఉపయోగిస్తాము ఉదాహరణ ” సృష్టించబడిన ఆబ్జెక్ట్ ఉదాహరణ పేరెంట్ లేదా చైల్డ్ క్లాస్‌కి చెందినదా అని ధృవీకరించడానికి ఆపరేటర్:
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
MyClass myclassObj = కొత్త నా తరగతి ( ) ;
ఉంటే ( myclassObj ఉదాహరణ నా తరగతి ) {
వ్యవస్థ . బయటకు . println ( ''myclassObj' వస్తువు 'MyClass'కి ఒక ఉదాహరణ' ) ;
} లేకపోతే ఉంటే ( myclassObj ఉదాహరణ MynewClass ) {
వ్యవస్థ . బయటకు . println ( ''myclassObj' వస్తువు 'MynewClass'కి ఒక ఉదాహరణ' ) ;
}
}
}
ఇచ్చిన అవుట్‌పుట్ చూపిస్తుంది “ ఉదాహరణ ” ఆపరేటర్ ఆబ్జెక్ట్ రకాన్ని ఇలా ధృవీకరించారు నా తరగతి ”:
మేము జావాలో ఆబ్జెక్ట్ రకాన్ని పొందడానికి సంబంధించిన అన్ని పద్ధతులను సంకలనం చేసాము.
ముగింపు
జావాలో ఒక రకమైన వస్తువును పొందడానికి, మీరు ' getClass() 'పద్ధతి లేదా' ఉదాహరణ ” ఆపరేటర్. ఈ పద్ధతులను ముందే నిర్వచించిన మరియు వినియోగదారు నిర్వచించిన తరగతుల కోసం ఆబ్జెక్ట్ రకాలను తనిఖీ చేయడానికి ఉపయోగించవచ్చు. getClass() పద్ధతి తరగతి పేరును అందిస్తుంది, అయితే “instanceof” ఆపరేటర్ బూలియన్ విలువను అందిస్తుంది, ఇక్కడ “ నిజం ” ఆ వస్తువు పేర్కొన్న తరగతికి చెందినదని సూచిస్తుంది; లేకపోతే, అది తిరిగి వస్తుంది ' తప్పుడు ”. ఈ కథనం జావాలో ఆబ్జెక్ట్ రకాన్ని పొందడానికి అన్ని పద్ధతులను అందించింది.