జావాలో అనామక తరగతిని ఎలా అమలు చేయాలి

అనామక తరగతులు చిన్న కోడ్‌ను వ్రాయడానికి మిమ్మల్ని అనుమతిస్తాయి మరియు అదే సమయంలో తరగతిని ప్రకటించడానికి మరియు తక్షణం చేయడానికి మిమ్మల్ని అనుమతిస్తాయి. ఈ తరగతులకు పేర్లు లేవు, మీరు ఏ తరగతిని ఒక్కసారి మాత్రమే ఉపయోగించాలనుకున్నప్పుడు ఇది ఉపయోగించబడుతుంది. ఇది జావా ప్రోగ్రామింగ్ యొక్క ముఖ్యమైన అంశం. కింది క్రమంలో జావాలో అనామక తరగతి అంటే ఏమిటో అర్థం చేసుకుందాం:

• అనామక తరగతులను ప్రకటించడం
• జావాలో అనామక తరగతి సింటాక్స్
• జావాలో అనామక తరగతిని సృష్టించే మార్గాలు
• రెగ్యులర్ మరియు అనామక తరగతి మధ్య వ్యత్యాసం

అనామక తరగతులను ప్రకటించడం

సాధారణంగా మేము ఒక తరగతిని సృష్టిస్తాము, అంటే మేము తరగతిని ప్రకటిస్తాము కాని, అనామక తరగతులు వ్యక్తీకరణలు అంటే అనామక తరగతిని మరొకదానిలో నిర్వచించాము వ్యక్తీకరణ . సరళమైన మాటలలో, అనామక అంతర్గత తరగతి పేర్లు లేని తరగతి మరియు ఒక వస్తువు మాత్రమే సృష్టించబడుతుంది.

తరగతి యొక్క ఉపవర్గాన్ని సృష్టించకుండా తరగతి లేదా ఇంటర్ఫేస్ యొక్క ఓవర్‌లోడింగ్ పద్ధతులతో వస్తువు యొక్క ఉదాహరణను సృష్టించవలసి వచ్చినప్పుడు అనామక తరగతి ఉపయోగపడుతుంది.

అనామకను రెండు విధాలుగా సృష్టించవచ్చు:

• తరగతి (వియుక్త కూడా కావచ్చు)
• ఇంటర్ఫేస్

అనామక తరగతిలో మనం ఈ క్రింది వాటిని ప్రకటించవచ్చు:

• క్షేత్రాలు
• అదనపు పద్ధతులు
• ఇన్‌స్టాన్స్ ఇనిషియలైజర్స్
• స్థానిక తరగతులు

జావాలో అనామక తరగతి సింటాక్స్

అనామక తరగతి యొక్క వాక్యనిర్మాణం కన్స్ట్రక్టర్ మాదిరిగానే ఉంటుంది, ఈ క్రింది స్నిప్పెట్‌లో చూపిన విధంగా బ్లాక్‌లో క్లాస్ డెఫినిషన్ ఉంది:

// అనామక క్లాస్ = ఇంటర్ఫేస్, నైరూప్య / కాంక్రీట్ తరగతి. అనామక క్లాస్ t = క్రొత్త అనామక క్లాస్ () {// పద్ధతులు మరియు ఫీల్డ్‌లు పబ్లిక్ శూన్యమైన కొన్ని పద్ధతి () code // కోడ్ ఇక్కడకు వెళుతుంది}}

ఈ క్రింది ఉదాహరణను పరిశీలిద్దాం:

కింది ఉదాహరణ,హలోఅనొనిమస్ క్లాస్, స్థానిక వేరియబుల్స్ యొక్క ప్రారంభ ప్రకటనలలో అనామక తరగతులను ఉపయోగిస్తుందిగ్రీట్‌సోమియోన్కానీ, వేరియబుల్ ప్రారంభించడానికి స్థానిక తరగతిని ఉపయోగిస్తుందిగ్రీట్‌వర్ల్డ్:

పబ్లిక్ క్లాస్ HelloAnonymousClass {interface HelloWorld {public void sayHello () public void sayHelloTo (స్ట్రింగ్ ఎవరో)} public void sayHello () {class GreetWorld HelloWorld {string name = 'world' public void sayHello () {sayHelloTo ('world')} public void sayHelloTo (స్ట్రింగ్ ఎవరో) {name = someone System.out.println ('హలో' + పేరు)}} HelloWorld gratWorld = new GreetWorld () HelloWorld gratSomeone = new HelloWorld () {string name = 'jon' public void sayHello ( ) {sayHelloTo ('జోన్')} పబ్లిక్ శూన్యత చెప్పండి హలోటో (స్ట్రింగ్ ఎవరో) {name = ఎవరైనా System.out.println ('హోలా' + పేరు)}} గ్రీట్‌వర్ల్డ్.సేహెల్లో () గ్రీట్‌సొమోన్.సేహెల్లోటో ('డో')} పబ్లిక్ స్టాటిక్ void main (స్ట్రింగ్ ... అర్గ్స్) {HelloAnonymousClass myApp = new HelloAnonymousClass () myApp.sayHello ()}}

అనామక తరగతి వ్యక్తీకరణ అని మనం చూసినట్లుగా, వాక్యనిర్మాణం కన్స్ట్రక్టర్ లాగా ఉంటుంది తప్ప బ్లాక్లో క్లాస్ డెఫినిషన్ ఉంది. గ్రీట్‌సోమియోన్ వస్తువు యొక్క తక్షణాన్ని పరిగణించండి:

హలోవర్ల్డ్ గ్రీట్‌సోమియోన్ = కొత్త హలోవర్ల్డ్ () {స్ట్రింగ్ పేరు = 'జాన్' పబ్లిక్ శూన్యత చెప్పండి హలో () {సేహెల్లోటో ('జోన్')} పబ్లిక్ శూన్యమైన సే హలోటో (స్ట్రింగ్ ఎవరో) {పేరు = ఎవరైనా System.out.println ('హోలా' + పేరు) }}

అనామక తరగతి ఈ క్రింది వాటితో కూడి ఉంటుంది:

• కొత్త ఆపరేటర్.
• ఇది ఇంటర్ఫేస్ను అమలు చేయవచ్చు లేదా తరగతిని పొడిగించవచ్చు. పై ఉదాహరణలో వలె, ఇది ఇంటర్ఫేస్ను అమలు చేస్తోంది.
• ఇది కన్స్ట్రక్టర్‌కు వాదనలు పంపడానికి సాధారణ తరగతుల మాదిరిగానే కుండలీకరణాలను కలిగి ఉంటుంది.
• పద్ధతి ప్రకటనలను కలిగి ఉన్న శరీరాన్ని కలిగి ఉంటుంది. ప్రకటనలు అనుమతించబడవు.

అనామక తరగతి ప్రకటనలలో భాగంగా ఉండాలి.

పై ఉదాహరణలో, అనామక తరగతి వ్యక్తీకరణ ప్రారంభించిన ప్రకటనలో భాగంగ్రీట్‌సోమియోన్.

జావాలో అనామక తరగతిని సృష్టించే మార్గాలు

జావాలో ఇన్నర్ క్లాస్ సృష్టించడానికి 3 మార్గాలు ఉన్నాయి

జావాలో ప్రోగ్రామ్ నుండి ఎలా నిష్క్రమించాలి

• తరగతిని విస్తరించడం ద్వారా

మేము ఇతర తరగతిని విస్తరించడం ద్వారా అనామక అంతర్గత తరగతిని సృష్టించగలము, థ్రెడ్ తరగతిని ఉపయోగించడం ద్వారా మనం ఒక థ్రెడ్‌ను సృష్టించవలసి ఉంటుందని అనుకుందాం.

// ఇతర తరగతి తరగతిని విస్తరించడం ద్వారా అనామక ఇన్నర్ క్లాస్‌ని వివరించే ప్రోగ్రామ్ .out.println ('చైల్డ్!')}} t.start () System.out.println ('పేరెంట్!')}}

అవుట్పుట్:

తల్లిదండ్రులు!

పిల్లవాడు!

• ఇంటర్ఫేస్ను అమలు చేయడం ద్వారా

ఇంటర్ఫేస్ను అమలు చేయడం ద్వారా మేము అనామక అంతర్గత తరగతిని కూడా సృష్టించవచ్చు. ఇప్పుడు, మేము అదే విధంగా తరగతిని విస్తరించడం ద్వారా అంతర్గత తరగతిని సృష్టించినప్పుడు, ఇంటర్ఫేస్ను అమలు చేసే తరగతిని సృష్టించవచ్చు.

// ఇంటర్ఫేస్ క్లాస్‌ను అమలు చేయడం ద్వారా అనామక ఇన్నర్ క్లాస్‌ను వివరించే ప్రోగ్రామ్ అనామక థ్రెడ్‌క్లాస్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {// ఇంటర్‌ఫేస్‌ను అమలు చేసే అనామక ఇన్నర్ క్లాస్ .println ('చైల్డ్!')}} థ్రెడ్ t = కొత్త థ్రెడ్ (r) t.start () System.out.println ('పేరెంట్!')}}

అవుట్పుట్:

తల్లిదండ్రులు!

క్రమబద్ధీకరించు శ్రేణి సి ++ ఆరోహణ

పిల్లవాడు!

• ఒక పద్ధతి / కన్స్ట్రక్టర్‌కు వాదనగా

వాక్యనిర్మాణాన్ని అర్థం చేసుకోవడానికి క్రింది ఉదాహరణను చూద్దాం:

// ఆర్గ్యుమెంట్ క్లాస్ ద్వారా అనామక ఇన్నర్ క్లాస్‌ను వివరించే ప్రోగ్రామ్ out.println ('చైల్డ్!')}}) t.start () System.out.println ('పేరెంట్!')}}

అవుట్పుట్:

తల్లిదండ్రులు!

పిల్లవాడు!

రెగ్యులర్ మరియు అనామక ఇన్నర్ క్లాస్ మధ్య వ్యత్యాసం

• మేము అమలు చేయవచ్చు బహుళ సంఖ్యల ఇంటర్‌ఫేస్‌లు సాధారణ తరగతిని ఉపయోగించడం ద్వారా, అనామక అంతర్గత తరగతితో, మేము ఒక ఇంటర్‌ఫేస్‌ను మాత్రమే అమలు చేయగలము.

• రెగ్యులర్ క్లాస్‌తో మనం చేయగలం తరగతిని విస్తరించండి మరియు బహుళ ఇంటర్‌ఫేస్‌లను కూడా అమలు చేయండి, కాని, అనామక అంతర్గత తరగతితో, మేము ఒక తరగతిని విస్తరించవచ్చు లేదా ఇంటర్‌ఫేస్‌ను అమలు చేయవచ్చు, కానీ రెండూ ఒకే సమయంలో కాదు.

• అనామక మేము కన్స్ట్రక్టర్ రాయలేరు ఎందుకంటే అనామక అంతర్గత తరగతికి పేరు లేదు మరియు కన్స్ట్రక్టర్ పేరు తరగతి పేరు వలె ఉండాలి.

ఈ వ్యాసంలో, అనామక అంతర్గత తరగతి అంటే ఏమిటి మరియు మనం దానిని ఎలా సృష్టించగలమో చూశాము. మేము అనామక అంతర్గత తరగతి యొక్క వాక్యనిర్మాణం ద్వారా వెళ్ళాము మరియు అనామక తరగతిని 3 విధాలుగా ఎలా సృష్టించగలము మరియు దీనితో, మేము జావా వ్యాసంలో ఈ అనామక తరగతి ముగింపుకు వచ్చాము. చూడండి ఎడురేకా చేత.

ప్రశ్న ఉందా? ఈ వ్యాసం యొక్క వ్యాఖ్య విభాగంలో దీనిని పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.