getClass() పద్ధతి, క్లాస్ ఆబ్జెక్ట్ మరియు రిఫ్లెక్షన్‌కి పరిచయం

"హాయ్, అమిగో!"

"ఇప్పుడు ఇది ప్రధాన ఈవెంట్‌కి సమయం. మేము క్లాస్ క్లాస్‌తో పరిచయం పొందుతాము మరియు ప్రతిబింబం మీద తాకుతాము.
మీరు బహుశా ఇప్పటికే గ్రహించినట్లుగా, జావాలోని ప్రతిదీ ఒక వస్తువు. మరియు ఒక వస్తువుకు ఏమి కావాలి? ప్రతి వస్తువుకు ఏమి నిర్వచిస్తుంది దాని గురించి ఏమిటి?"

"ఒక తరగతి!"

"సరే! బాగా చేసారు. ప్రతి వస్తువుకు ఒక తరగతి ఉంటుంది. కానీ వస్తువులను తిరిగి పొందడం... కొన్ని వస్తువులు పూర్తిగా ఒక ఎంటిటీని కలిగి ఉంటాయి, మరికొన్ని వాటిని నిర్వహించడంలో సహాయపడతాయి."

"ఈ రెండో రకం ఫైల్‌అవుట్‌పుట్‌స్ట్రీమ్ మరియు థ్రెడ్‌లను కలిగి ఉంటుంది. మీరు థ్రెడ్ ఆబ్జెక్ట్‌ని సృష్టించినప్పుడు , కొత్త థ్రెడ్ సృష్టించబడదు. ప్రారంభ() పద్ధతిని పిలిచిన తర్వాత థ్రెడ్ జావా వర్చువల్ మెషీన్ ద్వారా సృష్టించబడుతుంది. ఈ ఆబ్జెక్ట్ కేవలం ప్రక్రియను నిర్వహించడానికి సహాయపడుతుంది."

" ఫైల్‌అవుట్‌పుట్‌స్ట్రీమ్‌తో సమానంగా ఉంటుంది: ఫైల్ డిస్క్‌లో నిల్వ చేయబడుతుంది మరియు OS నిల్వ మరియు యాక్సెస్‌ని నిర్వహిస్తుంది. అయితే జావా వర్చువల్ మెషీన్ సహాయంతో మనం ఫైల్ ఆబ్జెక్ట్‌ల ద్వారా దానితో పరస్పర చర్య చేయవచ్చు."

"అవును, నాకు ఇది ఇప్పటికే అర్థమైంది."

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

"అది ఊహించడం కష్టం కాదు."

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

"ప్రతి తరగతి మరియు ఆబ్జెక్ట్ « క్లాస్ ఆబ్జెక్ట్ »తో అనుబంధించబడి ఉంటాయి."

Class clazz = Integer.class;

Class clazz = int.class;

Class clazz = "123".getClass();

Class clazz = new Object().getClass();

"వావ్! ఎంత ఆసక్తికరంగా!"

"జావాలో క్లాస్ అనే పదం కీలకపదమని మరియు వేరియబుల్ పేరుగా ఉపయోగించబడదని మీకు గుర్తుందా ?"

"ఓహ్, నాకు తెలుసు, నాకు తెలుసు. నేను మర్చిపోయాను."

"మీరు ఇప్పటికే క్లాస్ ఆబ్జెక్ట్‌ని ఎక్కడైనా ఉపయోగించారా?"

"అవును, ఈక్వల్స్ పద్ధతి యొక్క మా స్వంత అమలును వ్రాసినప్పుడు మేము దానిని ఉపయోగించాము."

"అవును, వస్తువులు ఒకే తరగతిని కలిగి ఉన్నాయో లేదో పరీక్షించడానికి మీరు getClass() పద్ధతిని ఉపయోగించవచ్చు."

"మరియు మీరు ఈ వస్తువుతో ఏమి చేయగలరు?"

"సరే, చాలా విషయాలు:"

Class s = int.class;
String name = s.getName();

Class s = Class.forName("java.lang.String");

Object o1 = String.valueOf(1);
Object o2 = 123 + "T";
o1.getClass() == o2.getClass();

"ఆసక్తికరంగా ఉంది, కానీ నేను అనుకున్నంత చల్లగా లేదు."

"మీకు ఇది చల్లగా ఉండాలనుకుంటున్నారా? ప్రతిబింబం కూడా ఉంది .  ప్రతిబింబం చాలా బాగుంది."

" ప్రతిబింబం అంటే ఏమిటి ?"

" ప్రతిబింబం అనేది దాని గురించి సమాచారాన్ని పొందే తరగతి సామర్థ్యం. జావాలో ప్రత్యేక తరగతులు ఉన్నాయి:  ఫీల్డ్ మరియు మెథడ్ , క్లాస్‌ల కోసం క్లాస్ క్లాస్‌ని పోలి ఉంటాయి . క్లాస్ ఆబ్జెక్ట్‌లు మిమ్మల్ని క్లాస్ గురించి సమాచారాన్ని పొందేలా చేస్తాయి, ఫీల్డ్ ఆబ్జెక్ట్‌లు ఫీల్డ్ గురించి సమాచారాన్ని అందిస్తాయి. , మరియు మెథడ్ ఆబ్జెక్ట్ ఒక పద్ధతి గురించి సమాచారాన్ని అందిస్తుంది. మరియు మీరు వాటితో ఏమి చేయగలరో చూడండి:"

Class[] interfaces = List.class.getInterfaces();

Class parent = String.class.getSuperclass();

Method[] methods = List.class.getMethods();

String s = String.class.newInstance();

String s = String.class.newInstance();
Method m = String.class.getMethod("length");
int length = (int) m.invoke(s)

"వావ్! ఇప్పుడు నిజంగా బాగుంది!"