ఈ కథనం, మొదటిసారిగా, డిజైన్ నమూనాల భావనను ఎదుర్కొన్న, సింగిల్టన్ అనే పదాన్ని విన్న లేదా సింగిల్టన్ నమూనాను అమలు చేసిన, కానీ ఏమి జరుగుతుందో అర్థం కాని ఎవరికైనా ఉద్దేశించబడింది. స్వాగతం! కోడ్‌జిమ్ విద్యార్థులు లెవెల్ 15లో మొదటిసారి డిజైన్ నమూనాలను ఎదుర్కొంటారు, కెప్టెన్ ఊహించని విధంగా జావా సింగిల్టన్ నమూనాను సోమరితనంతో అమలు చేయడం ద్వారా వారి అవగాహనను "బలపరచుకోమని" వారిని కోరినప్పుడు. మొదటిసారిగా సింగిల్టన్ నమూనా గురించి విన్న విద్యార్థులకు తక్షణమే చాలా ప్రశ్నలు ఉంటాయి: ప్రపంచంలో డిజైన్ నమూనా అంటే ఏమిటి? మనకు అది ఎందుకు అవసరం? సింగిల్టన్ అంటే ఏమిటి ? చివరకు, సోమరితనం అమలు అంటే ఏమిటి? ఈ ప్రశ్నలకు క్రమంలో సమాధానాలు చూద్దాం.
ప్రపంచంలో డిజైన్ నమూనా ఏమిటి?
ఈ ప్రశ్నకు ఉత్తమ అవగాహనతో సమాధానం ఇవ్వడానికి ఒక చిన్న చరిత్ర ఉందని నేను నమ్ముతున్నాను. నలుగురు ప్రసిద్ధ ప్రోగ్రామింగ్ రచయితలు (ఎరిచ్ గామా, జాన్ వ్లిస్సైడ్స్, రాల్ఫ్ జాన్సన్ మరియు రిచర్డ్ హెల్మ్) ఒక ఆసక్తికరమైన ఆలోచనతో ముందుకు వచ్చారు. సాఫ్ట్‌వేర్ డెవలప్‌మెంట్‌లో దాదాపు ఒకే విధమైన సమస్యలను పరిష్కరించడం మరియు అదే విధంగా నిర్మాణాత్మక కోడ్‌ను వ్రాయడం తరచుగా అవసరమని వారు గమనించారు. కాబట్టి ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్‌లో తరచుగా ఉపయోగించాల్సిన సాధారణ నమూనాలను వివరించాలని వారు నిర్ణయించుకున్నారు. వారి పుస్తకం డిజైన్ ప్యాటర్న్స్: ఎలిమెంట్స్ ఆఫ్ రీయూజబుల్ ఆబ్జెక్ట్-ఓరియెంటెడ్ సాఫ్ట్‌వేర్ పేరుతో 1994లో ప్రచురించబడింది. పుస్తకం పేరు చాలా పొడవుగా ఉంది మరియు ప్రజలు దానిని గ్యాంగ్ ఆఫ్ ఫోర్ ద్వారా పుస్తకం అని పిలవడం ప్రారంభించారు. మొదటి ఎడిషన్‌లో 23 నమూనాలు ఉన్నాయి. తరువాత, డజన్ల కొద్దీ ఇతర నమూనాలు కనుగొనబడ్డాయి.
డిజైన్ నమూనా అనేది ఒక సాధారణ సమస్యకు ప్రామాణికమైన పరిష్కారం.
మరియు సింగిల్టన్ నమూనా వాటిలో ఒకటి.
మనకు డిజైన్ నమూనాలు ఎందుకు అవసరం?
మీరు నమూనాలు తెలియకుండా ప్రోగ్రామ్ చేయవచ్చు: అన్నింటికంటే, స్థాయి 15 ద్వారా, మీరు ఇప్పటికే కోడ్‌జిమ్‌లో వందలాది మినీ-ప్రోగ్రామ్‌లు ఉన్నాయని కూడా తెలియకుండానే వ్రాసారు. డిజైన్ నమూనాలు ఒక రకమైన సాధనం అని ఇది సూచిస్తుంది, దీని ఉపయోగం మాస్టర్‌ను ఔత్సాహిక నుండి వేరు చేస్తుంది: డిజైన్ నమూనాలు ఒక సాధారణ సమస్యను ఎలా సరిగ్గా పరిష్కరించాలో వివరిస్తాయి. దీని అర్థం నమూనాలను తెలుసుకోవడం మీ సమయాన్ని ఆదా చేస్తుంది. ఆ విధంగా, అవి అల్గారిథమ్‌ల మాదిరిగానే ఉంటాయి. ఉదాహరణకు, మీరు
బ్లాక్‌జాక్ మరియు సంఖ్యలతో మీ స్వంత సార్టింగ్ అల్గారిథమ్‌ని సృష్టించవచ్చుమరియు అలా ఎక్కువ సమయం వెచ్చించండి లేదా మీరు చాలా కాలంగా అర్థం చేసుకున్న మరియు వివరించిన దాన్ని అమలు చేయవచ్చు. డిజైన్ నమూనాలతో కూడా ఇది వర్తిస్తుంది. అదనంగా, డిజైన్ నమూనాలతో, కోడ్ మరింత ప్రామాణికంగా మారుతుంది మరియు తగిన నమూనాను ఉపయోగిస్తున్నప్పుడు, మీరు తప్పులు చేసే అవకాశం తక్కువగా ఉంటుంది, ఎందుకంటే నమూనా యొక్క సాధారణ ఆపదలు చాలా కాలం క్రితం గుర్తించబడ్డాయి మరియు తొలగించబడ్డాయి. అన్నిటికీ మించి, నమూనాల పరిజ్ఞానం ప్రోగ్రామర్లు ఒకరినొకరు బాగా అర్థం చేసుకోవడంలో సహాయపడుతుంది. మీరు మీ తోటి ప్రోగ్రామర్‌లకు సుదీర్ఘ వివరణను అందించడానికి ప్రయత్నించే బదులు నమూనా పేరును చెప్పవచ్చు. సంగ్రహంగా, డిజైన్ నమూనాలు మీకు సహాయపడతాయి:
చక్రాన్ని తిరిగి ఆవిష్కరించవద్దు, బదులుగా ప్రామాణిక పరిష్కారాలను ఉపయోగించండి;
కోడ్ ప్రమాణీకరించు;
పరిభాషను ప్రామాణీకరించండి;
ఈ విభాగాన్ని ముగించడానికి, డిజైన్ నమూనాల మొత్తం శరీరాన్ని మూడు పెద్ద సమూహాలుగా విభజించవచ్చని మేము గమనించాము:
చివరగా, సింగిల్టన్ నమూనా
సింగిల్టన్ ఒక సృష్టి నమూనా . ఈ నమూనా తరగతికి ఒక ఉదాహరణ మాత్రమే ఉందని నిర్ధారిస్తుంది మరియు ఈ వస్తువు కోసం గ్లోబల్ యాక్సెస్ పాయింట్‌ను అందిస్తుంది. వివరణ నుండి, ఈ నమూనా రెండు సందర్భాలలో వర్తింపజేయాలని స్పష్టంగా ఉండాలి:
మీ ప్రోగ్రామ్‌కు నిర్దిష్ట తరగతికి చెందిన ఒకటి కంటే ఎక్కువ ఆబ్జెక్ట్‌లు సృష్టించకూడదని కోరినప్పుడు. ఉదాహరణకు, కంప్యూటర్ గేమ్‌లో హీరో క్లాస్ ఉండవచ్చు మరియు గేమ్‌లోని ఏకైక హీరోని వివరించే ఒక హీరో వస్తువు మాత్రమే ఉండవచ్చు.
మీరు ఆబ్జెక్ట్‌కు గ్లోబల్ యాక్సెస్ కోసం పాయింట్‌ను అందించాల్సిన అవసరం వచ్చినప్పుడు. మరో మాటలో చెప్పాలంటే, మీరు ప్రోగ్రామ్‌లో ఎక్కడి నుండైనా వస్తువును అందుబాటులో ఉంచాలి. అయ్యో, గ్లోబల్ వేరియబుల్‌ని సృష్టించడం సరిపోదు, ఎందుకంటే ఇది వ్రాయడం-రక్షించబడదు: ఎవరైనా వేరియబుల్ విలువను మార్చవచ్చు, కాబట్టి ఆబ్జెక్ట్ యొక్క గ్లోబల్ యాక్సెస్ పాయింట్ కోల్పోవచ్చు. సింగిల్టన్ యొక్క ఈ లక్షణాలు అవసరం, ఉదాహరణకు, మీరు డేటాబేస్‌తో పనిచేసే వస్తువును కలిగి ఉన్నప్పుడు మరియు మీరు ప్రోగ్రామ్‌లోని వివిధ భాగాల నుండి డేటాబేస్‌ను యాక్సెస్ చేయాలి. గతంలో సృష్టించిన ఉదాహరణను భర్తీ చేసే కోడ్‌ను ఎవరూ వ్రాయలేదని సింగిల్టన్ నిర్ధారిస్తుంది .
కాబట్టి సింగిల్టన్ ఈ రెండు అవసరాలను సంతృప్తిపరిచింది: ప్రోగ్రామ్‌లో ఒక నిర్దిష్ట రకమైన వస్తువు మాత్రమే ఉండాలి మరియు దానికి గ్లోబల్ యాక్సెస్ ఉండాలి. స్థాయి 15లోని ఉదాహరణలో, కింది పని కోసం ఈ నమూనాను అమలు చేయమని కెప్టెన్ మిమ్మల్ని అడుగుతాడు:
సోమరితనంతో కూడిన సింగిల్టన్ యొక్క ఉదాహరణను కనుగొనండి .
ఒకే సూత్రాన్ని ఉపయోగించి వేర్వేరు ఫైల్‌లలో మూడు సింగిల్టన్ తరగతులను - సూర్యుడు, చంద్రుడు, భూమిని సృష్టించండి.
అమలు చేయండిప్లానెట్సూర్యుడు , చంద్రుడు మరియు భూమి తరగతుల్లో ఇంటర్‌ఫేస్ .
సొల్యూషన్ క్లాస్ యొక్క స్టాటిక్ బ్లాక్‌లో కాల్ చేయండిreadKeyFromConsoleAndInitPlanetపద్ధతి.
అమలు చేయండిreadKeyFromConsoleAndInitPlanetపద్ధతి కార్యాచరణ:
5.1 కన్సోల్ నుండి ఒక స్ట్రింగ్ పరామితిని చదవండి
5.2 పరామితి ఒకదానికి సమానంగా ఉంటేప్లానెట్ఇంటర్‌ఫేస్ స్థిరాంకాలు, తగిన ది ప్లానెట్ ఆబ్జెక్ట్‌ని సృష్టించండి.
విధి పరిస్థితులను జాగ్రత్తగా చదివిన తర్వాత, ఇక్కడ సింగిల్టన్ ఎందుకు అవసరమో మనం స్పష్టంగా చూడవచ్చు. వాస్తవానికి, కింది తరగతుల్లో ప్రతి ఒక్కదానిని సృష్టించమని మేము కోరాము: సూర్యుడు , చంద్రుడు , భూమి . మనం ఒకటి కంటే ఎక్కువ సూర్యుడు/చంద్రుడు/భూమిని సృష్టించకూడదని భావించడం అర్ధమే. లేకపోతే, మీరు మీ స్టార్ వార్స్ వెర్షన్‌ను వ్రాస్తున్నట్లయితే తప్ప, మేము అసంబద్ధమైన పరిస్థితిలోకి వస్తాము. మూడు దశల్లో జావాలో సింగిల్టన్ నమూనాను అమలు చేయడం జావాలో, సాధారణ కన్‌స్ట్రక్టర్‌ని ఉపయోగించి సింగిల్టన్ ప్రవర్తనను అమలు చేయడం సాధ్యం కాదు, ఎందుకంటే ఒక కన్‌స్ట్రక్టర్ ఎల్లప్పుడూ కొత్త వస్తువును తిరిగి ఇస్తుంది. అందువలన, సింగిల్టన్ యొక్క అన్ని అమలులుకన్స్ట్రక్టర్‌ను దాచిపెట్టడం, సింగిల్టన్ వస్తువు యొక్క జీవితకాలాన్ని నియంత్రించే పబ్లిక్ స్టాటిక్ పద్ధతిని సృష్టించడం మరియు కొత్తగా కనిపించే అన్ని వస్తువులను "నాశనం" చేయడం. సింగిల్టన్ యాక్సెస్ చేయబడితే , అది కొత్త వస్తువును సృష్టించాలి (ఒకవేళ ప్రోగ్రామ్‌లో ఇప్పటికే ఉనికిలో లేకుంటే) లేదా ఇప్పటికే ఉన్న దానిని తిరిగి ఇవ్వాలి. దీన్ని సాధించడానికి:
మీరు తరగతికి ఒకే వస్తువును నిల్వ చేసే ప్రైవేట్ స్టాటిక్ ఫీల్డ్‌ను ఇవ్వాలి:
public class LazyInitializedSingleton {
private static LazyInitializedSingleton instance; // #1
}
(డిఫాల్ట్) కన్స్ట్రక్టర్‌ను ప్రైవేట్‌గా చేయండి. దీని అర్థం ఇది తరగతి వెలుపల యాక్సెస్ చేయబడదు మరియు కొత్త వస్తువులను తిరిగి ఇవ్వదు:
public class LazyInitializedSingleton {
private static LazyInitializedSingleton instance;
private LazyInitializedSingleton(){} // #2
}
సింగిల్‌టన్‌ని పొందడానికి ఉపయోగించే స్థిరమైన సృష్టి పద్ధతిని ప్రకటించండి:
public class LazyInitializedSingleton {
private static LazyInitializedSingleton instance;
private LazyInitializedSingleton() {}
public static LazyInitializedSingleton getInstance() { // #3
if (instance == null) { // If the object has not yet been created
instance = new LazyInitializedSingleton(); // Create a new object
}
return instance; // Return the previously created object
}
}
ఎగువ ఉదాహరణ కొంత వికృతంగా ఉంది, ఎందుకంటే మేము కేవలం కన్స్ట్రక్టర్‌ను దాచిపెట్టి, ప్రామాణిక కన్స్ట్రక్టర్‌కు బదులుగా మా స్వంత పద్ధతిని అందిస్తాము. ఈ కథనం కోడ్‌జిమ్ విద్యార్థులు ఈ నమూనాతో (మరియు సాధారణంగా డిజైన్ నమూనాలు) పరిచయంలోకి వచ్చేలా చూడటం లక్ష్యంగా పెట్టుకున్నందున, మరింత సంక్లిష్టమైన సింగిల్టన్ అమలుల యొక్క సూక్ష్మ నైపుణ్యాలు ఇక్కడ వివరించబడవు. ప్రోగ్రామ్ యొక్క సంక్లిష్టతను బట్టి, ఈ నమూనాను మరింత మెరుగుపరచాల్సిన అవసరం ఉందని మాత్రమే మేము గమనించాము. ఉదాహరణకు, బహుళ థ్రెడ్ వాతావరణంలో (థ్రెడ్‌ల గురించిన కథనాలను చూడండి), అనేక విభిన్న థ్రెడ్‌లు ఏకకాలంలో సింగిల్టన్ పద్ధతిని యాక్సెస్ చేయవచ్చు మరియు పైన వివరించిన కోడ్ పని చేయడం ఆగిపోతుంది, ఎందుకంటే ప్రతి ప్రత్యేక థ్రెడ్ క్లాస్ యొక్క ఉదాహరణను సృష్టించగలదు. ఫలితంగా, సరైన థ్రెడ్-సేఫ్ సింగిల్‌టన్‌లను రూపొందించడానికి ఇంకా అనేక విభిన్న విధానాలు ఉన్నాయి. కానీ అది మరొక కథ =)
మరి చివరగా... కెప్టెన్ అడిగాడు ఈ సోమరితనం ఏమిటి?
సోమరితనం ప్రారంభాన్ని వాయిదా వేసిన ఇనిషియలైజేషన్ అని కూడా అంటారు. ఇది ప్రోగ్రామింగ్ ట్రిక్, ఇక్కడ రిసోర్స్-ఇంటెన్సివ్ ఆపరేషన్ (మరియు ఒక వస్తువును సృష్టించడం అనేది రిసోర్స్-ఇంటెన్సివ్ ఆపరేషన్) ముందుగానే కాకుండా డిమాండ్‌పై నిర్వహించబడుతుంది. కాబట్టి మా సింగిల్టన్ జావా కోడ్‌లో వాస్తవానికి ఏమి జరుగుతుంది ? మరో మాటలో చెప్పాలంటే, మన వస్తువు అది యాక్సెస్ చేయబడిన సమయానికి సృష్టించబడుతుంది, ముందుగానే కాదు. సోమరితనం ప్రారంభించడం అనేది సింగిల్టన్ నమూనాతో కఠినంగా ముడిపడి ఉందని మీరు అనుకోకూడదు . ప్రాక్సీ మరియు ఫ్యాక్టరీ మెథడ్ వంటి ఇతర క్రియేషనల్ డిజైన్ నమూనాలలో కూడా లేజీ ఇనిషియలైజేషన్ ఉపయోగించబడుతుంది, అయితే ఇది మరొక కథ =)
GO TO FULL VERSION