🤹🏽 ⌚️ 🚇 अंतिम के साथ विरासत की सीमा क्यों? 🐓 👨🏼‍🔬 🕔

आपने गोफ के इस प्रसिद्ध कथन को शायद ही सुना हो: "रचना को कक्षा की विरासत के लिए पसंद करें।" और फिर, एक नियम के रूप में, लंबे विचारों पर चला गया कि एक गतिशील रचना की तुलना में सांख्यिकीय रूप से निर्धारित उत्तराधिकार कितना लचीला नहीं है।

लचीलापन बेशक एक उपयोगी डिज़ाइन सुविधा है। हालांकि, जब एक वास्तुकला चुनते हैं, तो हम मुख्य रूप से रखरखाव, परीक्षणशीलता, कोड पठनीयता, मॉड्यूल के पुन: उपयोग में रुचि रखते हैं। तो अच्छे डिजाइन के इन मानदंडों के साथ, विरासत भी एक समस्या है। "और अब, विरासत का उपयोग बिल्कुल नहीं करते?" - आप पूछते हैं।

आइए देखें कि वंशानुक्रम के माध्यम से कक्षाओं के बीच एक मजबूत निर्भरता कैसे आपके सिस्टम आर्किटेक्चर को अत्यधिक कठोर और नाजुक बना सकती है। और कोड में सबसे रहस्यमय और मायावी कीवर्ड का उपयोग क्यों करें - final । एक सरल क्रॉस-कटिंग उदाहरण का उपयोग करके तैयार किए गए विचारों का प्रदर्शन किया जाता है। लेख के अंत में, final कक्षाओं के साथ सुविधाजनक काम के लिए चालें और उपकरण हैं।

नाजुक आधार वर्ग की समस्या

नाजुक आधार वर्ग की समस्या

अच्छी वास्तुकला के लिए मुख्य मानदंडों में से एक ढीली युग्मन है , जो सॉफ्टवेयर मॉड्यूल के बीच अंतर्संबंध की डिग्री की विशेषता है। यह कुछ भी नहीं है कि कमजोर सगाई जीआरएएसपी पैटर्न की सूची का हिस्सा है जो कक्षाओं के बीच जिम्मेदारी साझा करने के लिए बुनियादी सिद्धांतों का वर्णन करता है।

कमजोर सगाई के कई फायदे हैं।

सॉफ्टवेयर मॉड्यूल के बीच निर्भरता को ढीला करके, आप अधिक लचीले आर्किटेक्चर बनाकर सिस्टम के रखरखाव और समर्थन की सुविधा प्रदान करते हैं।
उनके कामकाज को बाधित करने के जोखिम के बिना शिथिल युग्मित मॉड्यूल के समानांतर विकास की संभावना है।
कक्षा का तर्क अधिक स्पष्ट हो जाता है, कक्षा का सही तरीके से और अपने इच्छित उद्देश्य के लिए उपयोग करना आसान हो जाता है, और इसका उपयोग करना मुश्किल है - गलत।

परंपरागत रूप से, एक प्रणाली में निर्भरता को मुख्य रूप से प्रयुक्त वस्तु (सेवा) और उपयोग करने वाली वस्तु (क्लाइंट) के बीच संबंध के रूप में समझा जाता है। इस तरह के एक संबंध जब सेवा "ग्राहक" ( एक संबंध है ) का हिस्सा है, और ग्राहक उस में एम्बेडेड सेवा के व्यवहार के लिए जिम्मेदारी स्थानांतरित करता है, तो संबंध संबंध मॉडल। क्लाइंट और सेवा के बीच संबंधों को कमजोर करने में एक महत्वपूर्ण भूमिका निर्भरता उलटा सिद्धांत ( डीआईपी ) द्वारा निभाई जाती है , जो मॉड्यूल के बीच प्रत्यक्ष निर्भरता को एक सामान्य अमूर्त पर मॉड्यूल की पारस्परिक निर्भरता में परिवर्तित करने का प्रस्ताव करती है।

हालाँकि, आप भी एक -एक संबंध के ढांचे के भीतर निर्भरता को ढीला करके अनुप्रयोग वास्तुकला में काफी सुधार कर सकते हैं। डिफ़ॉल्ट वंशानुक्रम संबंध तंग युग्मन बनाता है, निर्भरता के सभी संभावित रूपों में सबसे मजबूत है, और इसलिए इसका उपयोग बहुत सावधानी से किया जाना चाहिए।

वंशानुक्रम के संबंध में मजबूत संबंध

वंशानुक्रम के संबंध में मजबूत संबंध

माता-पिता और बच्चे वर्गों के बीच साझा किए गए कोड की मात्रा बहुत बड़ी है। यह समस्या स्वयं को विशेष रूप से दृढ़ता से प्रकट करना शुरू करती है जब विरासत की अवधारणा का दुरुपयोग किया जाता है - विशेष रूप से क्षैतिज कोड पुन: उपयोग के लिए विरासत का उपयोग करना, और विशेष उपवर्ग बनाने के लिए नहीं। क्योंकि कोड का पुन: उपयोग करने के लिए वंशानुक्रम सबसे आसान तरीका है। आपको बस extends ParentClass लिखने की जरूरत है और यह बात है! आखिरकार, यह एकत्रीकरण, निर्भरता इंजेक्शन (DI), इंटरफ़ेस आवंटन की तुलना में बहुत सरल है।

वंशानुगत पदानुक्रम में वर्ग लिंकेज की कमी पारंपरिक रूप से गुंजाइश ( private , protected ) के प्रतिबंधक संशोधक का उपयोग करके प्राप्त की जाती है। एक राय यह भी है कि विशेष रूप से private संशोधक के साथ वर्ग के गुणों को घोषित किया जाना चाहिए। और protected संशोधक को बहुत सावधानी से और केवल विधियों पर लागू किया जाना चाहिए, क्योंकि यह माता-पिता और बच्चे वर्गों के बीच निर्भरता को प्रोत्साहित करता है।

हालांकि, विरासत की समस्याएं न केवल गुणों और विधियों को छिपाने में हैं, वे बहुत गहरे हैं। क्लासिक गोफ पुस्तक सहित आवेदन वास्तुकला पर बहुत सारे साहित्य, वंशानुक्रम के बारे में संदेह से भरे हुए हैं और अधिक लचीले डिजाइनों की ओर देखने का सुझाव देते हैं। लेकिन क्या यह केवल लचीलापन है? मैं विरासत की समस्याओं को व्यवस्थित करने के लिए नीचे प्रस्ताव करता हूं, और उसके बाद सोचता हूं कि उनसे कैसे बचा जाए।

चलो "प्रयोगात्मक खरगोश" के रूप में टिप्पणी के एक सरल वर्ग के साथ टिप्पणी ब्लॉक का सबसे सरल वर्ग लेते हैं। किसी संग्रह के अंदर समान कक्षाएं किसी भी परियोजना में बड़ी संख्या में पाई जाती हैं।

 class CommentBlock { /** @var Comment[]   */ private $comments = []; }

नीचे दिए गए उदाहरणों जानबूझ में सरलीकृत कर रहे हैं KISS कोड तैयार विचारों को दिखाने के लिए शैली। आप लेख से कोड उदाहरण और इस रिपॉजिटरी में उनके उपयोग पर एक विस्तृत एनोटेशन पा सकते हैं।

विरासत के मुद्दे

आइए सबसे स्पष्ट समस्या से शुरू करें, जो मुख्य रूप से वास्तुकला पर साहित्य में दी गई है।

वंशानुक्रम छुपाने के सिद्धांत का उल्लंघन करता है

चूंकि उपवर्ग में अभिभावक वर्ग के कार्यान्वयन विवरण तक पहुंच होती है, इसलिए अक्सर कहा जाता है कि वंशानुक्रम encapsulation का उल्लंघन करता है।

GoF, डिज़ाइन पैटर्न

यद्यपि क्लासिक पुस्तक, द गैंग ऑफ़ फोर, एन्कैप्सुलेशन उल्लंघनों से संबंधित है, यह कहना अधिक सटीक होगा कि "वंशानुक्रम छुपाने के सिद्धांत का उल्लंघन करता है । " आखिरकार, एन्कैप्सुलेशन डेटा उनके प्रसंस्करण के लिए डिज़ाइन किए गए तरीकों के साथ संयोजन है। लेकिन छुपाने का सिद्धांत सिर्फ कुछ सिस्टम घटकों के उपयोग को दूसरों के कार्यान्वयन के विवरण तक सीमित करता है।

वास्तुकला में छिपाव के सिद्धांत का पालन करने से स्थिर इंटरफ़ेस के माध्यम से मॉड्यूल की सगाई सुनिश्चित होती है। और अगर वर्ग वंशानुक्रम की अनुमति देता है, तो यह स्वचालित रूप से निम्नलिखित प्रकार के स्थिर इंटरफेस प्रदान करता है:

सार्वजनिक इंटरफ़ेस इस वर्ग के सभी ग्राहकों द्वारा उपयोग किया जाता है;
सभी बाल वर्गों द्वारा उपयोग किया जाने वाला संरक्षित इंटरफ़ेस ।

यानी सार्वजनिक एपीआई द्वारा प्रदान की गई क्षमताओं की तुलना में बाल वर्ग में बहुत बड़ा शस्त्रागार है। उदाहरण के लिए, यह अपने protected गुणों में छिपे मूल वर्ग की आंतरिक स्थिति को प्रभावित कर सकता है।

अक्सर, चाइल्ड क्लास को अभिभावक वर्ग के उन सभी तत्वों तक पहुँच की आवश्यकता नहीं होती है, जो विरासत के माध्यम से सुलभ होते हैं, हालाँकि, आप कुछ उपवर्गों के लिए चुनिंदा वर्गों के protected सदस्यों तक पहुँच प्रदान नहीं कर सकते हैं। चाइल्ड क्लास पेरेंट क्लास के संरक्षित इंटरफेस पर निर्भर होने लगती है।

कक्षा विरासत का मुख्य कारण, सबसे अधिक बार, इसके कार्यान्वयन को पुन: उपयोग करके मूल वर्ग की कार्यक्षमता का विस्तार करना है। यदि प्रारंभ में संरक्षित इंटरफ़ेस के माध्यम से मूल वर्ग के कार्यान्वयन तक पहुंच में समस्याएं नहीं आती थीं, तो जैसे ही सिस्टम विकसित होता है, प्रोग्रामर इस पहुंच का उपयोग बाल वर्ग के तरीकों में करना शुरू कर देता है और पदानुक्रम में लिंक को मजबूत करता है।

अभिभावक वर्ग को अब न केवल सार्वजनिक इंटरफ़ेस , बल्कि संरक्षित इंटरफ़ेस की भी स्थिरता बनाए रखने के लिए मजबूर किया जाता है , क्योंकि इसमें किसी भी बदलाव के कारण बाल वर्गों के काम में समस्याएँ आएंगी। हालांकि, protected वर्ग के सदस्यों का उपयोग करने से इनकार करना असंभव है। यदि संरक्षित इंटरफ़ेस बाहरी सार्वजनिक इंटरफ़ेस से पूरी तरह मेल खाएगा, अर्थात। अभिभावक वर्ग केवल public और private सदस्यों का उपयोग करेगा, फिर विरासत में आम तौर पर कोई मतलब नहीं होता है।

वास्तव में, protected कीवर्ड वास्तव में वर्ग के सदस्यों के लिए कोई सुरक्षा प्रदान नहीं करता है। ऐसे सदस्यों तक पहुँच प्राप्त करने के लिए, इसे कक्षा से विरासत में प्राप्त करना पर्याप्त है, और बाल वर्ग के ढांचे के भीतर आपके पास छिपाने के सिद्धांत का उल्लंघन करने का हर अवसर है। गलत तरीके से एक वर्ग का उपयोग करना बहुत आसान हो जाता है, जो खराब वास्तुकला के पहले लक्षणों में से एक है।

संरक्षित इंटरफ़ेस के माध्यम से एक वर्ग का उपयोग करना

एक संरक्षित इंटरफ़ेस के माध्यम से छुपाने के सिद्धांत का उल्लंघन

इससे भी महत्वपूर्ण बात यह है कि, इनकैप्सुलेटेड एलिमेंट्स (स्थिरांक, गुण, विधियाँ) न केवल पढ़ने योग्य और बच्चे की कक्षा में लागू हो जाते हैं, बल्कि ओवरराइड भी हो सकते हैं। ऐसा अवसर एक छिपे हुए खतरे से भरा होता है - इस तरह के परिवर्तनों के कारण, बच्चे वर्ग की वस्तुओं का व्यवहार मूल वर्ग की वस्तुओं के साथ असंगत हो सकता है। इस मामले में, कोड में उन बिंदुओं पर बाल वर्ग की वस्तुओं को प्रतिस्थापित करना जहां मूल वर्ग की वस्तुओं के व्यवहार को अप्रत्याशित परिणामों का नेतृत्व करना था।

उदाहरण के लिए, हम CommentBlock वर्ग की कार्यक्षमता को CommentBlock :

 class CommentBlock { /** @var Comment[]   */ protected $comments = []; /**       `$comments` */ public function getComment(string $key): ?Comment { return $this->comments[$key] ?? null; } }

और हम इसे CustomCommentBlock वर्ग CustomCommentBlock से विरासत में CustomCommentBlock , जिसमें हम छुपाने के लिए सभी संभावनाओं का लाभ उठाते हैं।

 class CustomCommentBlock extends CommentBlock { /** *    * *    (information hiding) *     `CommentBlock::$comments`, *     */ public function setComments(array $comments): void { $this->comments = $comments; } /** *    ,   `Comment::getKey()` * *       */ public function getComment(string $key): ?Comment { foreach ($this->comments as $comment) { if ($comment->getKey() === $key) { return $comment; } } return null; } }

छिपाव उल्लंघन के सामान्य मामले निम्नानुसार हैं:

चाइल्ड क्लास के तरीके अभिभावक वर्ग की स्थिति को प्रकट करते हैं और अभिभावक वर्ग के छिपे हुए सदस्यों तक पहुँच प्रदान करते हैं। अभिभावक वर्ग को डिजाइन करते समय ऐसा परिदृश्य संभवतः नहीं था, जिसका अर्थ है कि इसके तरीकों का तर्क संभवतः उल्लंघन होगा।
उदाहरण में, चाइल्ड क्लास सुरक्षित CommentBlock::$comments को संशोधित करने के लिए CustomCommentBlock::setComments() सेटर विधि प्रदान करता है CommentBlock::$comments संपत्ति मूल वर्ग में छिपी हुई है।
बालक वर्ग में अभिभावक वर्ग की पद्धति के व्यवहार को ओवरराइड करना। कभी-कभी डेवलपर्स इस सुविधा को संशोधित व्यवहार के साथ बच्चे की कक्षाएं बनाकर अभिभावक वर्ग की समस्याओं को हल करने के तरीके के रूप में देखते हैं।
उदाहरण में, CommentBlock::getComment() मूल श्रेणी में विधि CommentBlock::$comments में कुंजी पर निर्भर करती है CommentBlock::$comments साहचर्य सरणी। और बाल वर्ग में - टिप्पणियों की कुंजी के लिए, Comment::getKey() माध्यम से सुलभ Comment::getKey() विधि।

केला-बंदर-जंगल की समस्या

ऑब्जेक्ट-ओरिएंटेड भाषाओं के साथ समस्या यह है कि वे अपने पूरे निहित वातावरण के साथ खींचती हैं। आप सिर्फ एक केला चाहते थे, लेकिन परिणामस्वरूप आपको इस केले को पकड़े हुए एक गोरिल्ला मिला, और इसके अलावा सभी जंगल।

जो आर्मस्ट्रांग, एरलांग के निर्माता

सिस्टम आर्किटेक्चर में निर्भरता हमेशा मौजूद होती है। हालांकि, वंशानुक्रम कई जटिल कारकों को वहन करता है।

आप शायद एक ऐसी स्थिति में आ गए हैं, जैसे-जैसे सॉफ्टवेयर उत्पाद विकसित होता है, वर्ग पदानुक्रम काफी बढ़ गए हैं। उदाहरण के लिए

 class Block { /* ... */ } class CommentBlock extends Block { /* ... */ } class PopularCommentBlock extends CommentBlock { /* ... */ } class CachedPopularCommentBlock extends PopularCommentBlock { /* ... */ } /* .... */

आप विरासत और विरासत प्राप्त करते हैं, लेकिन आप यह तय नहीं कर सकते हैं कि कौन से सदस्य विरासत में प्राप्त करें। आप पदानुक्रम के पेड़ में सभी वर्गों के सभी विरासतों को विरासत में देते हैं। इसके अलावा, आपको पैरेंट क्लास के कार्यान्वयन पर एक मजबूत निर्भरता मिलती है, पेरेंट क्लास के मूल वर्ग पर, और इसी तरह। और इन निर्भरताओं को किसी भी तरह से कमजोर नहीं किया जा सकता है (जैसा कि डीआईपी के साथ एकत्रीकरण के विपरीत है)।

इस तथ्य का उल्लेख नहीं करने के लिए कि इस तरह की गहरी पदानुक्रम में एक पत्ता वर्ग लगभग निश्चित रूप से एकल जिम्मेदारी सिद्धांत ( एसआरपी ) का उल्लंघन करता है , पता है और बहुत अधिक करता है। आपने एक साधारण Block वर्ग के साथ विकास शुरू किया, फिर उसमें टिप्पणियों का चयन करने के लिए फ़ंक्शंस जोड़े, फिर लोकप्रियता के आधार पर छँटाई के लिए सुविधाएँ, संलग्न कैशिंग ... परिणामस्वरूप, आपको बहुत सारी जिम्मेदारियों के साथ एक वर्ग मिला और, इसके अलावा, शिथिल रूप से जुड़ा हुआ ( कम सहवास )

आप बस एक केला प्राप्त करना चाहते थे (पदानुक्रम में एक पत्ता वस्तु बनाएं) और आपको इसकी परवाह नहीं है कि यह निकटतम सुपरमार्केट को कैसे मिला (व्यवहार कैसे लागू किया गया, इसका परिणाम यह है)। हालांकि, विरासत के साथ, आपको जंगल से ही शुरू होने वाली पूरी पदानुक्रम की प्राप्ति को पूरा करने के लिए मजबूर किया जाता है। आपको जंगल की विशेषताओं और उनके कार्यान्वयन की बारीकियों को ध्यान में रखना चाहिए, जबकि आप केले पर ध्यान केंद्रित करना चाहते हैं।

नतीजतन, आपकी कक्षा की स्थिति कई मूल वर्गों में फैली हुई है। आप अपनी कक्षा पर बाहरी वातावरण (जंगल) के प्रभाव को केवल एनकैप्सुलेशन और छुपा के माध्यम से सीमित करके इस समस्या को हल कर सकते हैं। हालांकि, विरासत के साथ इसे हासिल करना असंभव है, क्योंकि वंशानुक्रम छुपाने के सिद्धांत का उल्लंघन करता है।

अब कैसे पदानुक्रम पेड़ में कहीं गहरे में बच्चे की कक्षाओं का परीक्षण करें, क्योंकि उनका कार्यान्वयन मूल कक्षाओं में बिखरा हुआ है? परीक्षण के लिए, आपको सभी मूल वर्गों की आवश्यकता होगी, और आप उन्हें किसी भी तरह से ओवरराइड नहीं कर सकते, क्योंकि आपका व्यवहार में नहीं बल्कि क्रियान्वयन में जुड़ाव है। चूँकि आपकी कक्षा को आसानी से अलग-थलग और परीक्षण नहीं किया जा सकता है, इसलिए आपको बहुत सी समस्याएं विरासत में मिलेंगी - स्थिरता, विस्तारशीलता और पुन: उपयोग के साथ।

डिफ़ॉल्ट खुली पुनरावृत्ति

हालाँकि, बच्चा वर्ग केवल अभिभावक के संरक्षित इंटरफेस पर निर्भर नहीं करता है। वह आंशिक रूप से उसके साथ एक भौतिक एहसास भी साझा करता है, इस पर निर्भर करता है और इसे प्रभावित कर सकता है। यह न केवल छिपाने के सिद्धांत का उल्लंघन करता है, बल्कि बाल वर्ग के व्यवहार को भी विशेष रूप से भ्रमित और अप्रत्याशित बनाता है।

ऑब्जेक्ट-ओरिएंटेड भाषाएँ डिफ़ॉल्ट रूप से खुली पुनरावृत्ति प्रदान करती हैं। PHP में, खुली पुनरावृत्ति छद्म-चर $this का उपयोग करके कार्यान्वित की जाती है। $this माध्यम से एक विधि कॉल को साहित्य में स्व-कॉल कहा जाता है।

स्व-कॉल वर्तमान कक्षा में विधि कॉल की ओर जाता है, या यह देर से बाध्यकारी के आधार पर वंशानुगत पदानुक्रम को गतिशील या पुनर्निर्देशित किया जा सकता है। इस पर निर्भर करते हुए, स्व-कॉल में विभाजित किया गया है:

डाउन-कॉल - एक विधि का एक कॉल जिसका कार्यान्वयन बच्चे के वर्ग में अतिप्रचलित है, पदानुक्रम में कम है।
अप-कॉल - एक ऐसी विधि के लिए एक कॉल जिसका कार्यान्वयन मूल वर्ग से विरासत में मिला है, उच्च पदानुक्रम में। आप parent::method() से parent::method() निर्माण के माध्यम से PHP में स्पष्ट रूप से कॉल कर सकते हैं।

तरीकों को लागू करने में डाउन-कॉल और अप-कॉल का लगातार उपयोग कक्षाओं को और भी अधिक बारीकी से करता है, जिससे वास्तुकला कठिन और भंगुर हो जाती है।

एक उदाहरण लेते हैं। हम मूल CommentBlock वर्ग में getComments() पद्धति को लागू करते हैं, जो टिप्पणियों की एक सरणी देता है।

 class CommentBlock { /* ... */ /** *        `getComment()`. * *        `CustomCommentBlock`, * ..   `CommentBlock::getComment()`  * `CustomCommentBlock::getComment()` . */ public function getComments(): array { $comments = []; foreach ($this->comments as $key => $comment) { $comments[] = $this->getComment($key); } return $comments; } }

यह विधि CommentBlock::getComment() के तर्क पर निर्भर करती है CommentBlock::getComment() और सहयोगी सरणी $comments की कुंजी द्वारा टिप्पणियों पर CommentBlock::getComment() । CustomCommentBlock वर्ग के संदर्भ में CommentBlock::getComments() विधि से, CommentBlock::getComments() के डाउन-कॉल CustomCommentBlock::getComment() विधि को निष्पादित किया जाएगा। हालाँकि, CustomCommentBlock::getComment() पद्धति का मूल वर्ग में अपेक्षा से भिन्न व्यवहार है। एक पैरामीटर के रूप में, इस विधि से टिप्पणी की key संपत्ति की उम्मीद है।

नतीजतन, CommentBlock::getComments() स्वचालित रूप से मूल वर्ग से विरासत में मिला, CommentBlock::getComments() साथ व्यवहार में असंगत निकला। getComments() के संदर्भ में कॉल getComments() सबसे अधिक संभावना null मानों की एक सरणी लौटाएगा।

मजबूत जुड़ाव के कारण, किसी वर्ग में परिवर्तन करते समय, आप केवल उसके व्यवहार पर ध्यान केंद्रित नहीं कर सकते हैं। आपको पदानुक्रम को नीचे और ऊपर सभी वर्गों के आंतरिक तर्क को ध्यान में रखने के लिए मजबूर किया जाता है। अभिभावक वर्ग में डाउन-कॉल की सूची और आदेश को ज्ञात और प्रलेखित किया जाना चाहिए, जो कि छुपाने के सिद्धांत का पर्याप्त उल्लंघन करता है। कार्यान्वयन विवरण मूल श्रेणी अनुबंध का हिस्सा बन जाते हैं।

साइड इफेक्ट नियंत्रण

पिछले उदाहरण में, समस्या माता-पिता और बच्चे की कक्षाओं में getComment() विधियों के तर्क में अंतर के कारण स्वयं प्रकट हुई। हालांकि, वर्ग पदानुक्रम में तरीकों के व्यवहार की समानता को नियंत्रित करने के लिए पर्याप्त नहीं है। यदि इन तरीकों के दुष्प्रभाव होते हैं तो समस्याएं आपका इंतजार कर सकती हैं।

साइड इफेक्ट्स के साथ फ़ंक्शन ( साइड इफेक्ट्स के साथ फ़ंक्शन) मुख्य प्रभाव के अलावा, सिस्टम की कुछ स्थिति को बदलता है - कॉल बिंदु पर परिणाम लौटाता है। दुष्प्रभावों के उदाहरण:

विधि के लिए बाहरी परिवर्तनशील (उदाहरण के लिए, ऑब्जेक्ट गुण);
स्थैतिक चर को विधि में बदलना;
बाहरी सेवाओं के साथ बातचीत।

इसलिए ये दुष्प्रभाव कार्यान्वयन के उस हिस्से पर भी हैं, जो वंशानुक्रम की प्रक्रिया में प्रभावी रूप से छिपाया नहीं जा सकता है।

कल्पना कीजिए कि CommentBlock टिप्पणियों में से एक का CommentBlock प्रतिनिधित्व प्राप्त करने के लिए CommentBlock वर्ग में viewComment() विधि को शामिल करने की आवश्यकता है।

 class CommentBlock { /** @var Comment[]   */ protected $comments = []; /**         */ public function viewComment(string $key): string { return $this->comments[$key]->view(); } }

बाल वर्ग में एक साइड इफेक्ट जोड़ें और इसका उद्देश्य निर्दिष्ट करें। हम वर्ग CountingCommentBlock लागू करते हैं, जो कैश में व्यक्तिगत टिप्पणियों के विचारों को गिनने CommentBlock क्षमता के CommentBlock पूरक करता है। क्लास को CounterInterface इंटरफेस के माध्यम से कंस्ट्रक्टर ( कंस्ट्रक्टर इंजेक्शन ) में PSR-16- संगत कैश के इंजेक्शन को स्वीकार करने दें (जो कि, हालांकि, PSR-16 से बाहर रखा गया था )। हम increment() विधि का उपयोग कैश में काउंटर वैल्यू को परमाणु वृद्धि के लिए करेंगे।

 class CountingCommentBlock extends CommentBlock { /** @var CounterInterface  */ private $cache; public function __construct(CounterInterface $cache) { $this->cache = $cache; } /**        */ public function viewComment(string $key): string { $this->cache->increment($key); return parent::viewComment($key); } }

सब कुछ अच्छा काम करता है। हालांकि, कुछ बिंदु पर, ब्लॉक में सभी टिप्पणियों का एक viewComments() प्रतिनिधित्व बनाने के लिए viewComments() फ़ंक्शन को जोड़ने का निर्णय लिया गया है। इस विधि को CommentBlock बेस क्लास में जोड़ा जाता है, और, एक नज़र में, सभी बाल वर्गों द्वारा इस पद्धति के कार्यान्वयन को विरासत में प्राप्त करना बहुत सुविधाजनक लगता है और बाल कक्षाओं में अतिरिक्त कोड लिखने से बचता है।

 class CommentBlock { /* ... */ /**           */ public function viewComments(): string { $view = ''; foreach ($this->comments as $key => $comment) { $view .= $comment->view(); } return $view; } }

हालाँकि, अभिभावक वर्ग को बाल वर्गों की कार्यान्वयन सुविधाओं के बारे में कुछ भी पता नहीं है। viewComments() (responsibility) CountingCommentBlock – .

 $commentBlock = new CountingCommentBlock(new SomeCache()); /* ... */ $commentBlock->viewComments();

. , .

« » . , viewComments() ( ).

, . , , , . – « » (" Fragile base class "). «- » – (fragility).

, ? . , CommentBlock , .

 class CommentBlock { /** @var Comment[]   */ protected $comments = []; /**         */ public function viewComment(string $key): string { return $this->comments[$key]->view(); } /**           */ public function viewComments(): string { $view = ''; foreach ($this->comments as $key => $comment) { $view .= $comment->view(); } return $view; } }

CountingCommentBlock .

 class CountingCommentBlock extends CommentBlock { /** @var CounterInterface  */ private $cache; public function __construct(CounterInterface $cache) { $this->cache = $cache; } /**        */ public function viewComment(string $key): string { $this->cache->increment($key); return parent::viewComment($key); } /**        */ public function viewComments(): string { foreach ($this->comments as $key => $comment) { $this->cache->increment($key); } return parent::viewComments(); } }

CommentBlock::viewComments() :

 $view .= $comment->view();

, viewComment() , – . . viewComment() viewComments() . , CommentBlock::viewComment() CommentBlock::viewComments() :

 class CommentBlock { /* ... */ public function viewComments(): string { $view = ''; foreach ($this->comments as $key => $comment) { $view .= $this->viewComment($key); //  `$comment->view()` } return $view; } }

CommentBlock , , . CommentBlock – , «». .

, . CountingCommentBlock . :

 $commentBlock = new CountingCommentBlock(new SomeCache()); /* ... */ $commentBlock->viewComments();

 CountingCommentBlock::viewComments() -> CommentBlock::viewComments() -> (n ) CountingCommentBlock::viewComment()

: CountingCommentBlock::viewComments() CountingCommentBlock::viewComment() . यानी – . CountingCommentBlock , , !

, protected . , . . , .

. , . , . , , « - ».

, . , « ». « » $this , private , .

, . , , . PHP ( public , protected , private ) final .

final

PHP . , , .. , , , . , final .

PHP 5 final , , . , .

#1.
...
#2
...

: , .

PHP, « final »

PHP . . final , .

, final – PHP, . , PHP : typehints , ..

final , , . यानी , . .

, , private , . , .

, , , API. , «» , . «» - . «» , .

API « ». , .

, final .

final

« »

– . , public protected .

, , . PHP ( -) . – , , , .

, () . « » ( Template method ).

, :

. , () . . final . – .
. . , . () .

, abstract , , final , . , , . , .. final .

. , , . , . . .., , - , , , . :

abstract ;
final , , .

. « » abstract final .

CommentBlock .

 abstract class CommentBlock { /**   */ protected $comments = []; /**         */ abstract public function viewComment(string $key): string; /**           */ final public function viewComments(): string { $view = ''; foreach ($this->comments as $key => $comment) { $view .= $this->viewComment($key); } return $view; } }

SimpleCommentBlock :

 final class SimpleCommentBlock extends CommentBlock { public function viewComment(string $key): string { return $this->comments[$key]->view(); } }

, , :

 final class CountingCommentBlock extends CommentBlock { /**  */ private $cache; public function __construct(CounterInterface $cache) { $this->cache = $cache; } /**        */ public function viewComment(string $key): string { $this->cache->increment($key); return $this->comments[$key]->view(); } }

«», . final final .

. , . , « » down-call , , . .

, , . , .

- , . extends , implements .

- . CommentBlock :

 interface CommentBlock { /**         */ public function viewComment(string $key): string; /**           */ public function viewComments(): string; }

 final class SimpleCommentBlock implements CommentBlock { /**   */ private $comments = []; public function viewComment(string $key): string { return $this->comments[$key]->view(); } public function viewComments(): string { $view = ''; foreach ($this->comments as $key => $comment) { $view .= $this->viewComment($key); } return $view; } }

, :

 final class CountingCommentBlock implements CommentBlock { /**   */ private $comments = []; /**  */ private $cache; public function __construct(CounterInterface $cache) { $this->cache = $cache; } /**        */ public function viewComment(string $key): string { $this->cache->increment($key); return $this->comments[$key]->view(); } public function viewComments(): string { $view = ''; foreach ($this->comments as $key => $comment) { $view .= $this->viewComment($key); } return $view; } }

implements - ( association ) .

-, . - . final , : , ..

. . , public . implements , () , , ( ISP ). , .

/ ( OCP )? final implements – PHP .

, , , . , implements , . .

final , . . – , implements final .

« », . implements , final .

, « », , . – SimpleCommentBlock CountingCommentBlock viewComments() .

, viewComments() , , , , . , . ( decorator pattern ). , « », – final , implements .

, CommentBlock , .

 interface CommentBlock { /**      */ public function getCommentKeys(): array; /**         */ public function viewComment(string $key): string; /**           */ public function viewComments(): string; }

, getCommentKeys() . . , protected , CommentBlock .

SimpleCommentBlock - «» . , , implements final .

 final class SimpleCommentBlock implements CommentBlock { /**   */ private $comments = []; public function getCommentKeys(): array { return array_keys($this->comments); } public function viewComment(string $key): string { return $this->comments[$key]->view(); } public function viewComments(): string { $view = ''; foreach ($this->comments as $key => $comment) { $view .= $this->viewComment($key); } return $view; } }

CountingCommentBlock - «» – OCP . CountingCommentBlock : CommentBlock .

 final class CountingCommentBlock implements CommentBlock { /**  CommentBlock */ private $commentBlock; /**  */ private $cache; public function __construct(CommentBlock $commentBlock, CounterInterface $cache) { $this->commentBlock = $commentBlock; $this->cache = $cache; } public function getCommentKeys(): array { return $this->commentBlock->getCommentKeys(); } public function viewComment(string $key): string { $this->cache->increment($key); return $this->commentBlock->viewComment($key); } public function viewComments() : string { $commentKeys = $this->getCommentKeys(); foreach ($commentKeys as $commentKey) { $this->cache->increment($commentKey); } return $this->commentBlock->viewComments(); } }

- CountingCommentBlock . , viewComment() . ( forwarding methods ).

, « ». getCommentKeys() . , «» , , .

, . , - «» . , – ( , SOLID) ( , , ).

. SimpleCommentBlock CountingCommentBlock CommentBlock , . -, .

, , final , CommentBlock .

SimpleCommentBlock CountingCommentBlock - « », . « » , . , « ». – .

, final , . , «--» – . DIP , .

: SimpleCommentBlock – ; CountingCommentBlock – SimpleCommentBlock , (). यानी , – SRP . , , ( cohesion ) .

« » – (, , ), , . , .

viewRandomComment() SimpleCommentBlock - CountingCommentBlock . , – viewRandomComment() . CountingCommentBlock::viewRandomComment() .

, viewComments() SimpleCommentBlock . CountingCommentBlock SimpleCommentBlock , .

 final class SimpleCommentBlock implements CommentBlock { /* ... */ /**         */ public function viewRandomComment(): string { $key = array_rand($this->comments); return $this->comments[$key]->view(); } /**      */ public function viewComments() : string { $view = ''; foreach ($this->comments as $key => $comment) { /*    `$this->viewComment()`      */ $view .= $this->comments[$key]->view(); } return $view; } }

: , , , , , .. .

PHP , , final , . , , , . , . . – , – .

, . PHPDoc , . : .

, , (.. , public protected ). PSR-19: PHPDoc tags , , . PHPDoc , « -».

JavaDoc @implSpec , . , PHPDoc API , .. public . @implSpec , API . , protected .

 class CommentBlock { /* ... */ /** *         *       *  (,    ) * * @implSpec      `$key` *    `$this->comments`      `view()` * * @param string $key   * @return string    */ public function viewComment(string $key): string { return $this->comments[$key]->view(); } }

PHPDoc @implSpec . $key . – view() .

, @implSpec :

( , , , ..).
parent::method() .

, «» . , self-call ( $this ) , , :

$this ;
;
.

 class CommentBlock { /* ... */ /** *           * * @implSpec    `$this->comments` *        `$this->viewComment()`. *       . * * @return string     */ final public function viewComments(): string { $view = ''; foreach ($this->comments as $key => $comment) { $view .= $this->viewComment($key); } return $view; } }

, viewComments() final . viewComment() , . :

viewComment() viewComments() ;
viewComments() viewComment() .

, . , , . « », CommentBlock CountingCommentBlock , . viewComment() viewComments() , , .

, , . PHPDoc API : , , .

, , , , , , «». – . PHPDoc , .

, , . – final , . . – « ».

. ;
final . .

, , final . final , . , . , ?

final . , , . , , final , .

final

« », , , , , . , protected . , final – , , , public , .

, , . , , , . – final .

, final ? नहीं। - , Opensource , , . IDE . , .

, , final . final , . .

final , . public ? – , ?

, . , final , , protected .

final , code review ( code review ? ;). , .

final ? ? ?
final ? ? ?

. , , code review . .

. final PHP5 . , , ( , ) .

, , . « » , . , C# virtual , – override . PHP final extandable , « final », extend .

, – . . . .

. , . , . final , , -. , , implements .

, , final .

final :

 final class SimpleCommentBlock { /* ... */ public function getCommentKeys(): array { /* ... */ } public function viewComment(string $key): string { /* ... */ } public function viewComments(): string { /* ... */ } }

. , final . , . .

, public . , , .

, .

 interface CommentBlock { public function getCommentKeys(): array; public function viewComment(string $key): string; public function viewComments(): string; }

 final class SimpleCommentBlock implements CommentBlock { /* ... */ }

-, . - CommentBlock . - .

 final class CountingCommentBlock implements CommentBlock { /* ... */ private $commentBlock; public function __construct(CommentBlock $commentBlock /* ,... */) { $this->commentBlock = $commentBlock; } /* ... */ }

, . , final , , - . , final .

final , . , «». , . final .

final

final – ( PHPUnit, Mockery ) «» ( test doubles ). , .

, :

 final class SimpleCommentBlockTest extends TestCase { public function testCreatingTestDouble(): void { $mock = $this->createMock(SimpleCommentBlock::class); } }

 Class "SimpleCommentBlock" is declared "final" and cannot be mocked.

, « » PHPUnit , :

 class Mock_SimpleCommentBlock_591bc3f3 extends SimpleCommentBlock { /* ... */ }

«» . -, , .. . , -, , PHPUnit . , .

final . : . .

– «» . , ( Post , Comment ) - ( value object ) ( stable ) . . classical TDD ( mockist TDD )

, ( volatile ) . , , «» – , . , «» , . ( DIP ), , «» .

, . यानी :

 interface CommentBlock { /* ... */ }

 final class SimpleCommentBlock implements CommentBlock { /* ... */ }

«» :

 final class CommentBlockTest extends TestCase { public function testCreatingTestDouble(): void { $mock = $this->createMock(CommentBlock::class); } }

«» , . :

«» ;
;
«» , .. DIP .

, «» – , -. , ( , ). , « » « ».

, final .

– -. -. , -, . Mockery .

 class SimpleCommentBlockTest extends TestCase { public function testCreatingProxyDouble() { /*    */ $simpleCommentBlock = new SimpleCommentBlock(); /*  - */ $proxy = Mockery::mock($simpleCommentBlock); /*    */ $proxy->shouldReceive('viewComment') ->andReturn('text'); /*     */ $this->assertEquals('text', $proxy->viewComment('1')); /* `$proxy`     `SimpleCommentBlock`  */ $this->assertNotInstanceOf(SimpleCommentBlock::class, $proxy); } }

– - . , instanceof . ( type declarations ), - .

« » – PHP, , . Bypass Finals , final . composer final :

 public function testUsingBypassFinals(): void { /*   `final` */ BypassFinals::enable(); $mock = $this->createMock(SimpleCommentBlock::class); }

final

, PHP . « » , final . , IDE final .

PHPStorm

PHPStorm . File | Settings | Editor | File and Code Templates Files PHP Class . final .

File | New | PHP Class :

 final class SimpleCommentBlock { }

, . . – .

PHPStorm Refactor | Extract | Interface . , . ( Replace class reference with interface where possible ) PHPDoc ( Move PHPDoc ).

 interface CommentBlock { /** PHPDoc */ public function viewComment(string $key): string; }

 final class SimpleCommentBlock implements CommentBlock { public function viewComment(string $key): string { /* ... */ } }

File | New | PHP Class -, . :

 final class CountingCommentBlock implements CommentBlock { /** @var CommentBlock */ private $commentBlock; }

Code | Generate | Constructor . .

 final class CountingCommentBlock implements CommentBlock { /* ... */ public function __construct(CommentBlock $commentBlock) { $this->commentBlock = $commentBlock; } }

– . Code | Generate | Implement Methods . , . PHPStorm «» , IntelliJ IDEA ReSharper .

 final class CountingCommentBlock implements CommentBlock { /* ... */ /** * @inheritDoc */ public function viewComment(string $key): string { // TODO: Implement viewComment() method. } }

PHPDoc . .

PHPStan

, . , , , final . ( ).

PHPStan . « » . PHPStan . .

FinalRule localheinz/phpstan-rules . PHPStan\Rules\Rule processNode() .

. , FinalRule « » allowAbstractClasses . , , classesNotRequiredToBeAbstractOrFinal .

, composer :

 composer require --dev phpstan/phpstan composer require --dev localheinz/phpstan-rules

FinalRule phpstan.neon :

 services: - class: Localheinz\PHPStan\Rules\Classes\FinalRule arguments: allowAbstractClasses: true classesNotRequiredToBeAbstractOrFinal: [] tags: - phpstan.rules.rule

( max ):

 vendor/bin/phpstan -lmax analyse src

  ------ ------------------------------------------------------------------------ Line CommentBlock.php ------ ------------------------------------------------------------------------ 10 Class CommentBlock is neither abstract nor final. ------ ------------------------------------------------------------------------

JSON Continuous Integration .

निष्कर्ष

, : final ! IDE, .

, , . – SOLID . , , .

, . :

;
final , , , ;
.

, - - . . . , , , , . , . ?

, – , . final . ( cognitive load ) – . – .

: final . . – . . . , . , .

final . ( SOLID ) ( fragile ) . , .

अंतिम के साथ विरासत की सीमा क्यों?

विरासत के मुद्दे

वंशानुक्रम छुपाने के सिद्धांत का उल्लंघन करता है

केला-बंदर-जंगल की समस्या

डिफ़ॉल्ट खुली पुनरावृत्ति

साइड इफेक्ट नियंत्रण

final

final

« »

final

final

final

निष्कर्ष

More articles: