3.1 సింగిల్టన్
Singleton అనేది ఒక సాధారణ డిజైన్ నమూనా, ఇది ఒకే-థ్రెడ్ అప్లికేషన్‌కు కొంత తరగతికి సంబంధించిన ఒకే ఉదాహరణ ఉంటుందని హామీ ఇస్తుంది మరియు ఈ ఉదాహరణకి గ్లోబల్ యాక్సెస్ పాయింట్‌ను అందిస్తుంది.
చాలా తరచుగా, అనుభవం లేని ప్రోగ్రామర్లు కొన్ని స్టాటిక్ క్లాస్‌లో యుటిలిటీ పద్ధతులను సమీకరించటానికి ఇష్టపడతారు - ఒక క్లాస్ స్టాటిక్ పద్ధతులను మాత్రమే కలిగి ఉంటుంది. ఈ విధానం అనేక నష్టాలను కలిగి ఉంది - ఉదాహరణకు, మీరు అటువంటి తరగతికి చెందిన వస్తువుకు సూచనను పాస్ చేయలేరు, అటువంటి పద్ధతులు పరీక్షించడం కష్టం, మరియు వంటివి.
ప్రత్యామ్నాయంగా, సింగిల్టన్ క్లాస్ సొల్యూషన్ ప్రతిపాదించబడింది: ఒక వస్తువు మాత్రమే ఉండే తరగతి. ఈ వస్తువును సృష్టించడానికి ప్రయత్నిస్తున్నప్పుడు, ఇది ఇప్పటికే ఉనికిలో లేనట్లయితే మాత్రమే సృష్టించబడుతుంది, లేకుంటే ఇప్పటికే ఉన్న ఉదాహరణకి సూచన తిరిగి ఇవ్వబడుతుంది.
క్లాస్ యొక్క ఉదాహరణను ఉపయోగించడం చాలా అవసరం, ఎందుకంటే అనేక సందర్భాల్లో విస్తృత కార్యాచరణ అందుబాటులోకి వస్తుంది. ఉదాహరణకు, ఈ తరగతి కొన్ని ఇంటర్‌ఫేస్‌లను అమలు చేయగలదు మరియు దాని వస్తువును ఇంటర్‌ఫేస్ అమలుగా ఇతర పద్ధతులకు పంపవచ్చు. స్టాటిక్ పద్ధతుల సమితితో ఏమి చేయలేము.
ప్రోస్:
- పద్ధతులు ఒక వస్తువుకు కట్టుబడి ఉంటాయి, స్టాటిక్ క్లాస్ కాదు - మీరు సూచన ద్వారా ఒక వస్తువును పాస్ చేయవచ్చు.
- ఆబ్జెక్ట్ పద్ధతులు పరీక్షించడం మరియు వెక్కిరించడం చాలా సులభం.
- ఒక వస్తువు అవసరమైనప్పుడు మాత్రమే సృష్టించబడుతుంది: సోమరి వస్తువు ప్రారంభించడం.
- ప్రారంభానికి అవసరం లేని అనేక సింగిల్స్ ఉంటే ప్రోగ్రామ్ యొక్క ప్రారంభ ప్రయోగాన్ని వేగవంతం చేయడం.
- ఒంటరిగా టెంప్లేట్-వ్యూహం లేదా అనేక వస్తువులుగా మార్చవచ్చు.
మైనస్‌లు:
- ఇంటర్-థ్రెడ్ రేసులను మరియు ఆలస్యాన్ని నియంత్రించడం మరింత కష్టమవుతుంది.
- బహుళ-థ్రెడ్ "ఒంటరి" "తల నుండి" వ్రాయడం కష్టం: దీర్ఘకాలంగా ఉన్న సింగిల్టన్కు ప్రాప్యత, ఆదర్శంగా, మ్యూటెక్స్ను తెరవకూడదు. మెరుగైన నిరూపితమైన పరిష్కారాలు.
- అసంపూర్తిగా ఉన్న సింగిల్ థ్రెడ్‌పై రెండు థ్రెడ్‌ల మధ్య వైరుధ్యం ఆలస్యంగా ఏర్పడుతుంది.
- ఆబ్జెక్ట్ చాలా కాలం పాటు సృష్టించబడుతుంటే, ఆలస్యం వినియోగదారుకు అంతరాయం కలిగించవచ్చు లేదా నిజ సమయానికి అంతరాయం కలిగించవచ్చు. ఈ సందర్భంలో, దాని సృష్టిని ప్రోగ్రామ్ ప్రారంభ దశకు బదిలీ చేయడం మంచిది.
- యూనిట్ పరీక్ష కోసం ప్రత్యేక లక్షణాలు అవసరం - ఉదాహరణకు, లైబ్రరీని "నాన్-లోన్లీ" మోడ్‌లో ఉంచడం మరియు పరీక్షలను ఒకదానికొకటి పూర్తిగా వేరుచేయడం.
- పూర్తయిన ప్రోగ్రామ్‌ను పరీక్షించడానికి ప్రత్యేక వ్యూహం అవసరం, ఎందుకంటే “సరళమైన లాంచ్‌బిలిటీ” అనే భావన కూడా అదృశ్యమవుతుంది, ఎందుకంటే లాంచ్‌బిలిటీ కాన్ఫిగరేషన్‌పై ఆధారపడి ఉంటుంది.
3.2 ఫ్యాక్టరీ [పద్ధతి]
ఫ్యాక్టరీ పద్ధతి అనేది ఒక నిర్దిష్ట తరగతి యొక్క ఉదాహరణలను సృష్టించడానికి ఒక ఇంటర్‌ఫేస్‌తో సబ్‌క్లాస్‌లను (తరగతులు-వారసత్వాలు) అందించే సాధారణ డిజైన్ నమూనా. సృష్టి సమయంలో, వారసులు ఏ తరగతిని సృష్టించాలో నిర్ణయించగలరు.
మరో మాటలో చెప్పాలంటే, ఈ టెంప్లేట్ మాతృ తరగతి యొక్క వారసులకు వస్తువుల సృష్టిని అప్పగిస్తుంది. ఇది ప్రోగ్రామ్ కోడ్‌లో కాంక్రీట్ క్లాస్‌లను ఉపయోగించకుండా, అధిక స్థాయిలో నైరూప్య వస్తువులను మార్చడానికి మిమ్మల్ని అనుమతిస్తుంది.
ఈ నమూనా ఆబ్జెక్ట్‌ను రూపొందించడానికి ఇంటర్‌ఫేస్‌ను నిర్వచిస్తుంది, అయితే ఆబ్జెక్ట్‌ను ఏ క్లాస్‌పై ఆధారం చేసుకోవాలో నిర్ణయించడానికి సబ్‌క్లాస్‌లకు దానిని వదిలివేస్తుంది. ఫ్యాక్టరీ పద్ధతి సబ్‌క్లాస్‌ల సృష్టిని అప్పగించడానికి తరగతిని అనుమతిస్తుంది. ఎప్పుడు ఉపయోగించబడుతుంది:
- ఏ సబ్‌క్లాస్‌ల యొక్క ఏ వస్తువులు సృష్టించాలో తరగతికి ముందుగానే తెలియదు.
- ఒక తరగతి రూపొందించబడింది, తద్వారా అది సృష్టించే వస్తువులు సబ్‌క్లాస్‌ల ద్వారా పేర్కొనబడతాయి.
- తరగతి తన బాధ్యతలను అనేక సహాయక ఉపవర్గాలలో ఒకదానికి అప్పగిస్తుంది మరియు ఈ బాధ్యతలను ఏ తరగతి తీసుకుంటుందో నిర్ణయించడానికి ప్రణాళిక చేయబడింది.
3.3 వియుక్త కర్మాగారం
వియుక్త కర్మాగారం అనేది ఒక సాధారణ డిజైన్ నమూనా, ఇది వాటి కాంక్రీట్ తరగతులను పేర్కొనకుండా సంబంధిత లేదా పరస్పర ఆధారిత వస్తువుల కుటుంబాలను సృష్టించడానికి ఇంటర్‌ఫేస్‌ను అందిస్తుంది.
ఒక వియుక్త తరగతి ఫ్యాక్టరీని సృష్టించడం ద్వారా నమూనా అమలు చేయబడుతుంది, ఇది సిస్టమ్ భాగాలను రూపొందించడానికి ఇంటర్‌ఫేస్ (ఉదాహరణకు, విండో ఇంటర్‌ఫేస్ కోసం, ఇది విండోస్ మరియు బటన్లను సృష్టించగలదు). అప్పుడు ఈ ఇంటర్‌ఫేస్‌ను అమలు చేసే తరగతులు వ్రాయబడ్డాయి.
ప్రోగ్రామ్ సృష్టించబడిన కొత్త వస్తువుల ప్రక్రియ మరియు రకాల నుండి స్వతంత్రంగా ఉండవలసిన సందర్భాలలో ఇది ఉపయోగించబడుతుంది. కుటుంబాలు లేదా సంబంధిత వస్తువుల సమూహాలను సృష్టించడం అవసరం అయినప్పుడు, ఒకే సందర్భంలో వివిధ సెట్ల నుండి వస్తువులను ఏకకాలంలో ఉపయోగించుకునే అవకాశాన్ని మినహాయించి.
బలాలు:
- నిర్దిష్ట తరగతులను వేరు చేస్తుంది;
- ఉత్పత్తి కుటుంబాల భర్తీని సులభతరం చేస్తుంది;
- ఉత్పత్తి అనుకూలతకు హామీ ఇస్తుంది.
మీ ప్రోగ్రామ్ ఫైల్ సిస్టమ్‌తో పనిచేస్తుందని అనుకుందాం. Linuxలో పని చేయడానికి మీకు LinuxFile, LinuxDirectory, LinuxFileSystem వస్తువులు అవసరం. మరియు Windwosలో పని చేయడానికి, మీకు WindowsFile, WindowsDirectory, WindowsFileSystem తరగతులు అవసరం.
Path.of() ద్వారా సృష్టించబడిన పాత్ క్లాస్ అటువంటి సందర్భం. మార్గం నిజంగా తరగతి కాదు, కానీ ఇంటర్‌ఫేస్, మరియు ఇది WindowsPath మరియు LinuxPath అమలులను కలిగి ఉంది. మరియు ఏ రకమైన వస్తువు సృష్టించబడుతుందో మీ కోడ్ నుండి దాచబడుతుంది మరియు రన్‌టైమ్‌లో నిర్ణయించబడుతుంది.
3.4 నమూనా
ప్రోటోటైప్ అనేది ఉత్పాదక రూపకల్పన నమూనా.
ఈ నమూనా ప్రోటోటైప్ ఉదాహరణను ఉపయోగించి సృష్టించబడిన వస్తువుల రకాలను నిర్వచిస్తుంది మరియు ఈ నమూనాను కాపీ చేయడం ద్వారా కొత్త వస్తువులను సృష్టిస్తుంది. ఇది మీరు అమలు నుండి దూరంగా ఉండటానికి మరియు "ఇంటర్ఫేస్ల ద్వారా ప్రోగ్రామింగ్" సూత్రాన్ని అనుసరించడానికి అనుమతిస్తుంది.
సోపానక్రమం ఎగువన ఉన్న ఇంటర్‌ఫేస్/అబ్‌స్ట్రాక్ట్ క్లాస్ తిరిగి వచ్చే రకంగా పేర్కొనబడింది మరియు ఈ రకాన్ని అక్కడ అమలు చేసే వారసుడిని సంతతి తరగతులు భర్తీ చేయగలవు. సరళంగా చెప్పాలంటే, ఇది ఒక వస్తువును కన్స్ట్రక్టర్ ద్వారా సృష్టించే బదులు మరొక వస్తువును క్లోనింగ్ చేయడం ద్వారా సృష్టించే నమూనా.
నమూనా ఉపయోగించబడుతుంది:
- ఒక వస్తువును ప్రామాణిక పద్ధతిలో సృష్టించే అదనపు ప్రయత్నాన్ని నివారించడం (అంటే కన్స్ట్రక్టర్‌ని ఉపయోగించడం, ఈ సందర్భంలో మొత్తం వస్తువు యొక్క పూర్వీకుల సోపానక్రమం యొక్క కన్స్ట్రక్టర్‌లను కూడా పిలుస్తారు), ఇది అప్లికేషన్‌కు చాలా ఖరీదైనది అయినప్పుడు.
- వియుక్త ఫ్యాక్టరీ నమూనా వలె క్లయింట్ అప్లికేషన్‌లో ఆబ్జెక్ట్ సృష్టికర్తను వారసత్వంగా పొందకుండా ఉండండి.
మీ ప్రోగ్రామ్ ఉత్పత్తులను ఎలా సృష్టిస్తుంది, కంపోజ్ చేస్తుంది మరియు ప్రెజెంట్ చేస్తుంది అనే దాని గురించి పట్టించుకోనప్పుడు ఈ డిజైన్ నమూనాను ఉపయోగించండి:
- తక్షణ తరగతులు రన్ సమయంలో నిర్ణయించబడతాయి, ఉదాహరణకు, డైనమిక్ లోడింగ్ ఉపయోగించి;
- మీరు ఉత్పత్తి తరగతి శ్రేణికి సమాంతరంగా ఉండే బిల్డింగ్ క్లాస్ లేదా ఫ్యాక్టరీ హైరార్కీలను నివారించాలనుకుంటున్నారు;
- తరగతి ఉదాహరణలు అనేక విభిన్న రాష్ట్రాలలో ఒకదానిలో ఉండవచ్చు. ప్రతిసారి తగిన స్థితిలో తరగతిని మాన్యువల్‌గా ఇన్‌స్టాంటియేట్ చేయడం కంటే తగిన సంఖ్యలో ప్రోటోటైప్‌లను సెట్ చేయడం మరియు వాటిని క్లోన్ చేయడం మరింత సౌకర్యవంతంగా ఉండవచ్చు.