జావాలో ప్రైవేట్ కన్స్ట్రక్టర్‌ను ఎలా అమలు చేయాలి

కన్స్ట్రక్టర్లు వస్తువు యొక్క స్థితిని ప్రారంభించడానికి ఉపయోగించబడతాయి. పద్ధతుల మాదిరిగానే, ఒక కన్స్ట్రక్టర్ స్టేట్మెంట్ల సేకరణను కూడా కలిగి ఉండగలడు, దీనిని సూచనలు తప్ప మరేమీ కాదు. ఈ వ్యాసంలో, మేము ప్రైవేట్ కన్స్ట్రక్టర్ గురించి చర్చిస్తాము కింది క్రమంలో:

• జావాలో కన్స్ట్రక్టర్ పరిచయం
• సింగిల్టన్ క్లాస్
• జావాలో ప్రైవేట్ కన్స్ట్రక్టర్ ప్రభావం
• అంతర్గత కన్స్ట్రక్టర్ చైనింగ్
• సింగిల్టన్ క్లాస్ డిజైన్ సరళి

జావాలో కన్స్ట్రక్టర్ పరిచయం

ఆబ్జెక్ట్ సృష్టి సమయంలో కన్స్ట్రక్టర్లు అమలు చేస్తారు. కన్స్ట్రక్టర్ మరియు దాని అనువర్తనాల గురించి మంచి అవగాహన పొందడానికి, ఒక పెట్టెను తరగతిగా ఆలోచించండి. బాక్స్ తరగతి కొన్ని తరగతి వేరియబుల్స్ (అనగా పొడవు, వెడల్పు మరియు ఎత్తు) కలిగి ఉంటుందని భావించబడుతుంది. ఏదేమైనా, దాని వస్తువును సృష్టించే సమయంలో (అనగా కంప్యూటర్ మెమరీలో బాక్స్ ఉంది), కాబట్టి బాక్స్ దాని డైమెన్షనల్ పరిమాణాలకు నిర్వచించబడని విలువ లేకుండా ఉనికిలో ఉంటుంది.

స్పష్టంగా, లేదు.

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

ప్రైవేటుగా తయారు చేయబడిన కన్స్ట్రక్టర్‌కు కోడర్ అందించిన యాక్సెస్ స్పెసిఫైయర్‌ను కలిగి ఉన్న ఏ పద్ధతిని అయినా తరగతి లోపలనే యాక్సెస్ చేయవచ్చని అర్థం చేసుకోవడం చాలా అవసరం.

c ++ జావా పైథాన్

సింగిల్టన్ క్లాస్

పేరు నుండి, ఒక తరగతికి ఆ తరగతి వస్తువుల సంఖ్యను ఒకదానికి పరిమితం చేస్తే సింగిల్టన్ అని పిలవవచ్చు. అటువంటి సందర్భాల్లో ఒక తరగతికి ఒకటి కంటే ఎక్కువ వస్తువులు ఉండకూడదు. సింగిల్టన్ తరగతులు నెట్‌వర్కింగ్ మరియు డేటాబేస్ కనెక్టివిటీ వంటి భావనలలో సంపూర్ణంగా ఉపయోగించబడతాయి. సింగిల్టన్ తరగతి a ప్రైవేట్ తరగతి .

తరగతి యొక్క ఉదాహరణను సంగ్రహించడానికి మరొక మార్గం మరియు ఫలితాన్ని తిరిగి పొందడానికి తిరిగి వచ్చే పద్ధతి ఉండాలి. క్రింద దాని యొక్క సరైన ఉదాహరణ. మొదటి పిక్టోగ్రాఫ్ సంభావ్య ఫలితాన్ని వర్ణిస్తుంది, ఇక్కడ “a.x” యొక్క విలువ 20 కి సమానం మరియు “b.x” యొక్క విలువ 20 లో కూడా వస్తుంది. కోడ్‌లో, మేము సింగిల్టన్ ప్రైవేట్ తరగతిని నిర్వచించేటప్పుడు, దాని కన్స్ట్రక్టర్లను తరగతి వెలుపల యాక్సెస్ చేయలేము.

A.x = 20 విలువ

B.x = 20 విలువ

ప్రైవేట్ కన్స్ట్రక్టర్లను ఉపయోగించి సింగిల్టన్ // నమూనా అమలును ప్రదర్శించడానికి జావా ప్రోగ్రామ్. దిగుమతి java.io. * తరగతి MySingleton {static MySingleton instance = null public int x = 10 // ప్రైవేట్ కన్స్ట్రక్టర్‌ను క్లాస్ ప్రైవేట్ MySingleton () వెలుపల యాక్సెస్ చేయలేరు {} // వినియోగదారులకు ఉదాహరణలను అందించడానికి ఫ్యాక్టరీ పద్ధతి స్టాటిక్ పబ్లిక్ MySingleton getInstance () {if (instance == null) instance = new MySingleton () return instance}} // డ్రైవర్ క్లాస్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {MySingleton a = MySingleton.getInstance () MySingleton b = MySingleton.getInstance () ax = ax + 10 System.out.println ('గొడ్డలి విలువ =' + గొడ్డలి) System.out.println ('bx =' + bx విలువ)}}

జావాలో ప్రైవేట్ కన్స్ట్రక్టర్ ప్రభావం

ప్రైవేట్ కన్స్ట్రక్టర్లు మరొక తరగతి నుండి పొందిన తరగతులను యాక్సెస్ చేయలేరు. ఈ విధంగా, మేము పబ్లిక్ ఫంక్షన్ ఇవ్వాలి, దీనిని ప్రైవేట్ కన్స్ట్రక్టర్ అని పిలుస్తారు. ఒకవేళ, ఆబ్జెక్ట్ ప్రారంభించబడలేదు, లేదా ఆబ్జెక్ట్ ప్రారంభించబడితే దాన్ని తిరిగి పంపాలి. వస్తువులకు ఇది చాలా ఉపయోగకరంగా ఉంటుంది, ఇది ప్రారంభించబడదు. ఈ క్రింది సందర్భాల్లో ప్రైవేట్ కన్స్ట్రక్టర్ ఉపయోగించబడుతుంది:

• సంబంధిత తరగతులు, ఇవి స్టాటిక్ పద్ధతులు మరియు సభ్యులను మాత్రమే కలిగి ఉంటాయి.
• నిర్దిష్ట తరగతులు, ఇవి స్టాటిక్ ఫైనల్ సభ్యులను (స్థిరాంకాలు) విస్తృతంగా ఉపయోగించాయి.
• సింగిల్‌టన్లను చేర్చడానికి.
• ఫ్యాక్టరీ పద్ధతులను చేర్చడానికి.

టైప్-సేఫ్ అయిన గణనలను ఉపయోగించుకోవడానికి.

అంతర్గత కన్స్ట్రక్టర్ చైనింగ్

అంతర్గత కన్స్ట్రక్టర్ చైనింగ్ అంటే, ఒక కన్స్ట్రక్టర్ అదే తరగతికి చెందిన మరొక కన్స్ట్రక్టర్‌ను పిలిచినప్పుడు దానిని కన్స్ట్రక్టర్ చైనింగ్ అని పిలుస్తారు. తరగతి యొక్క మరొక కన్స్ట్రక్టర్ను పిలవడానికి ఈ కీవర్డ్ను ఉపయోగించడం మా కర్తవ్యం. కొన్ని సందర్భాల్లో, క్లాస్ వేరియబుల్స్ యొక్క కొన్ని డిఫాల్ట్ విలువలను నిర్వచించడానికి ఇది ఉపయోగించబడుతుంది. దయచేసి మరొక కన్స్ట్రక్టర్ కాల్ తప్పనిసరిగా కోడ్ బ్లాక్‌లోని మొదటి స్టేట్‌మెంట్ అని గుర్తుంచుకోండి.

అదనంగా, పునరావృత కాల్స్ ఉండకూడదు, ఇది అనంతమైన లూప్‌ను సృష్టిస్తుంది. ఇప్పుడు మనం జావా ప్రోగ్రామ్‌లో ఒక కన్స్ట్రక్టర్ చైనింగ్ యొక్క ఉదాహరణను చూద్దాం.

ప్యాకేజీ com.journaldev.constructor పబ్లిక్ క్లాస్ ఎంప్లాయీ {ప్రైవేట్ ఇంట్ ఐడి ప్రైవేట్ స్ట్రింగ్ పేరు పబ్లిక్ ఎంప్లాయీ () {ఇది ('జాన్ డో', 999) System.out.println ('డిఫాల్ట్ ఉద్యోగి సృష్టించబడింది')} పబ్లిక్ ఎంప్లాయీ (int i) { ఇది ('జాన్ డో', i) System.out.println ('డిఫాల్ట్ పేరుతో సృష్టించబడిన ఉద్యోగి')} ప్రభుత్వ ఉద్యోగి (స్ట్రింగ్ లు, పూర్ణాంకం i) {this.id = i this.name = s System.out.println ( 'ఎంప్లాయీ క్రియేట్')} పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {ఎంప్లాయీ ఎంప్ = కొత్త ఎంప్లాయీ () సిస్టం. = క్రొత్త ఉద్యోగి ('పంకజ్', 20) System.out.println (emp2) public public పబ్లిక్ స్ట్రింగ్ toString () {తిరిగి 'ID =' + id + ', పేరు =' + పేరు} public int getId () {return id } పబ్లిక్ శూన్య సెట్ఇడ్ (పూర్ణాంక ఐడి) {this.id = id} పబ్లిక్ స్ట్రింగ్ getName () {తిరిగి పేరు} పబ్లిక్ శూన్య సెట్‌నేమ్ (స్ట్రింగ్ పేరు) {this.name = name}}

సింగిల్టన్ క్లాస్ డిజైన్ సరళి

• తరగతి స్థాయి సభ్యుడు (ఆసక్తిగల ప్రారంభ విధానం):

1. మొదట, సింగిల్టన్ క్లాస్ యొక్క ప్రైవేట్ స్థిరమైన స్టాటిక్ ఉదాహరణను చేయండి.

2. అప్పుడు, ఒక స్టాటిక్ పద్ధతిని వ్రాయండి, ఇది సింగిల్టన్ క్లాస్ యొక్క వస్తువును తిరిగి ఇస్తుంది, దీనిని మేము క్లాస్-మెంబర్ ఉదాహరణగా సృష్టించాము.

   పూర్ణాంక జావాకు డబుల్ ప్రసారం

3. స్థిరమైన స్టాటిక్ ఉదాహరణను నేరుగా యాక్సెస్ చేయడానికి స్టాటిక్ సభ్యుడిని ప్రజలగా గుర్తించడం సాధ్యపడుతుంది.

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

• తరగతి స్థాయి సభ్యుడు (లేజీ ప్రారంభ విధానం):

1. మొదట, కన్స్ట్రక్టర్‌ను ప్రైవేట్‌గా ప్రారంభించండి.

2. అప్పుడు ఈ సింగిల్టన్ క్లాస్ యొక్క ప్రైవేట్ స్టాటిక్ ఉదాహరణను సృష్టించండి. దీన్ని తక్షణం చేయకూడదని గుర్తుంచుకోండి.

3. అప్పుడు, స్టాటిక్ పద్ధతిని వ్రాయండి, ఇది స్టాటిక్ ఇన్‌స్టాన్స్ సభ్యుడిని శూన్యంగా తనిఖీ చేస్తుంది మరియు ఉదాహరణను ప్రారంభిస్తుంది. చివరగా, ఇది సింగిల్టన్ క్లాస్ యొక్క వస్తువును తిరిగి ఇస్తుంది.

• తరగతి స్థాయి సభ్యుడు (డబుల్ లాక్ పద్ధతిలో లేజీ ప్రారంభించడం):

ఉదాహరణ శూన్యంగా ఉన్నప్పుడు రెండు ఏకకాలంలో “if” స్టేట్‌మెంట్‌లోకి ప్రవేశించే రెండు థ్రెడ్‌లు నడుస్తున్నట్లు పరిగణించండి. ఎక్కడ, ఒక థ్రెడ్ ఒక ఉదాహరణను సృష్టించడానికి సమకాలీకరించబడిన బ్లాకులోకి వెళుతుంది, మరొకటి నిరోధించబడుతుంది. మొదటి థ్రెడ్ సమకాలీకరించబడిన బ్లాక్‌లో ఉన్నందున, క్యూలోని థ్రెడ్ మరొక సింగిల్టన్ వస్తువును సృష్టిస్తుంది. దయచేసి రెండవ థ్రెడ్ సమకాలీకరించబడిన బ్లాక్‌లోకి ప్రవేశించినప్పుడు, ఉదాహరణ శూన్యంగా ఉందో లేదో తనిఖీ చేయడంలో విఫలమవుతుంది.

• సమూహ ఇన్నర్ క్లాస్ ఉపయోగించి (లేజీ లోడ్ పద్ధతి):

  సి ++ లో గోటో

ఇక్కడ, ఇది జావా లాంగ్వేజ్ స్పెసిఫికేషన్స్ (జెఎల్ఎస్) పై ఆధారపడి ఉంటుంది. జావా వర్చువల్ మెషిన్ స్టాటిక్ డేటా-సభ్యులను డిమాండ్‌లో మాత్రమే లోడ్ చేస్తుంది. ఈ విధంగా, సింగిల్టన్ క్లాస్ మొదట JVM చేత లోడ్ అవుతుంది. అందువల్ల, ఒక తరగతిలో స్టాటిక్ డేటా సభ్యుడు లేడు

సింగిల్టన్ క్లాస్ హోల్డర్ SINGLE_INSTANCE ని లోడ్ చేయదు. మేము getIntance పద్ధతిని ప్రారంభించినప్పుడు, ఇది మాత్రమే జరుగుతుంది. తరగతి ప్రారంభించడం అమలుకు JLS హామీ ఇస్తుంది. లోడింగ్ మరియు ప్రారంభించడం కోసం స్టాటిక్ గెట్ఇన్స్టాన్స్ () పద్ధతిలో స్పష్టమైన సమకాలీకరణ కోసం ఒక నిబంధన. ప్రారంభించడం స్టాటిక్ వేరియబుల్ SINGLE_INSTANCE ను వరుస మార్గంలో సృష్టిస్తున్నందున, getInstance () యొక్క అన్ని ఏకకాల ఆహ్వానాలు సమకాలీకరణ ఓవర్ హెడ్ లేకుండా తిరిగి వస్తాయి.

• ఎనుమ్స్ ఉపయోగించడం ద్వారా

పైన పేర్కొన్న అన్ని విధానాలు అన్ని సందర్భాల్లో పూర్తి పరిష్కారాలు కావు. ప్రతిబింబం ఉపయోగించి పై అమలుల యొక్క బహుళ సందర్భాలను సృష్టించవచ్చు. రెండు సందర్భాల్లో, మేము ప్రైవేట్ కన్స్ట్రక్టర్‌ను దాటవేయవచ్చు మరియు బహుళ సందర్భాలను సృష్టించవచ్చు. అందువల్ల, ఎనుమ్స్ ఉపయోగించి సింగిల్టన్ తరగతిని సృష్టించడం కొత్త విధానం. ఎనుమ్స్ ఫీల్డ్‌లు సమయ స్థిరాంకాలు కంపైల్ చేయబడినందున, అవి వాటి ఎనుమ్ రకానికి ఉదాహరణలు. ఎనుమ్ రకాన్ని మొదటిసారి ప్రస్తావించినప్పుడు అవి నిర్మించబడతాయి.

దీనితో, మేము జావా వ్యాసంలో ప్రైవేట్ కన్స్ట్రక్టర్ చివరికి వస్తాము. ప్రైవేట్ కన్స్ట్రక్టర్ల గురించి మీకు అవగాహన వచ్చిందని మరియు వాటిని జావాలో ఎలా ఉపయోగించవచ్చో నేను ఆశిస్తున్నాను.

చూడండి ప్రపంచవ్యాప్తంగా విస్తరించి ఉన్న 250,000 మందికి పైగా సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించబడింది. ఈ కోర్సు మీకు జావా ప్రోగ్రామింగ్‌లోకి రావడానికి మరియు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌లకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.

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