मैं अपने कार्यक्रम में वस्तुओं को अपरिवर्तनीय बनाने के लाभ देखता हूं। जब मैं वास्तव में अपने आवेदन के लिए एक अच्छे डिजाइन के बारे में गहराई से सोच रहा हूं तो मैं स्वाभाविक रूप से अपनी कई वस्तुओं को अपरिवर्तनीय रूप से प्राप्त करता हूं। यह अक्सर उस बिंदु पर आता है जहां मैं अपनी सभी वस्तुओं को अपरिवर्तनीय रखना चाहूंगा ।
यह प्रश्न एक ही विचार से संबंधित है, लेकिन कोई जवाब नहीं बताता है कि अपरिवर्तनीयता के लिए एक अच्छा तरीका क्या है और वास्तव में इसका उपयोग कब करना है। क्या कुछ अच्छे अपरिवर्तनीय डिज़ाइन पैटर्न हैं? सामान्य विचार "वस्तुओं को अपरिवर्तनीय बनाता है जब तक कि आपको पूरी तरह से उन्हें बदलने की आवश्यकता न हो" जो व्यवहार में बेकार है।
मेरा अनुभव है कि अपरिवर्तनीयता मेरे कोड को कार्यात्मक प्रतिमान तक ले जाती है और यह प्रगति हमेशा होती है:
- मुझे सूची, मानचित्र आदि जैसे डेटा संरचनाओं में लगातार (कार्यात्मक अर्थों में) की आवश्यकता है।
- क्रॉस रेफ़रेंस के साथ काम करना बेहद असुविधाजनक है (जैसे कि ट्री नोड अपने बच्चों को संदर्भित करते हुए, जबकि बच्चे अपने माता-पिता को संदर्भित करते हैं) जो मुझे क्रॉस रेफरेंस का उपयोग नहीं करने देता है, जो फिर से मेरे डेटा संरचनाओं और कोड को अधिक कार्यात्मक बनाता है।
- वंशानुक्रम किसी भी अर्थ को बनाने के लिए रुक जाता है और मैं इसके बजाय रचना का उपयोग करना शुरू कर देता हूं।
- ओओपी के पूरे मूल विचार जैसे एनकैप्सुलेशन अलग होने लगते हैं और मेरी वस्तुएं कार्यों की तरह दिखना शुरू हो जाती हैं।
इस बिंदु पर मैं व्यावहारिक रूप से OOP प्रतिमान से कुछ भी नहीं का उपयोग कर रहा हूं और बस एक विशुद्ध रूप से कार्यात्मक भाषा पर स्विच कर सकता हूं। इस प्रकार मेरा प्रश्न: क्या अच्छी अपरिवर्तनीय ओओपी डिजाइन के लिए एक सुसंगत दृष्टिकोण है या क्या यह हमेशा ऐसा होता है कि जब आप अपरिवर्तनीय विचार को अपनी पूर्ण क्षमता पर ले जाते हैं, तो आप हमेशा एक कार्यात्मक भाषा में प्रोग्रामिंग करते हैं, जिसे ओओपी दुनिया से अब और कुछ भी ज़रूरत नहीं है? क्या यह तय करने के लिए कोई अच्छा दिशानिर्देश हैं कि कौन सी कक्षाएं अपरिवर्तनीय होनी चाहिए और यह सुनिश्चित करने के लिए परस्पर बने रहना चाहिए कि ओओपी अलग नहीं होता है?
बस सुविधा के लिए, मैं एक उदाहरण प्रदान करूंगा। आइए, आपके पास ChessBoardअपरिवर्तनीय शतरंज के टुकड़ों (विस्तारित सार वर्ग) का एक संग्रह हैPiece)। ओओपी दृष्टिकोण से, एक टुकड़ा बोर्ड पर अपनी स्थिति से वैध चालें उत्पन्न करने के लिए जिम्मेदार है। लेकिन चालों को उत्पन्न करने के लिए टुकड़ा को अपने बोर्ड के लिए एक संदर्भ की आवश्यकता होती है जबकि बोर्ड को अपने टुकड़ों के संदर्भ की आवश्यकता होती है। ठीक है, आपकी ओओपी भाषा के आधार पर इन अपरिवर्तनीय क्रॉस-रेफरेंस को बनाने के लिए कुछ तरकीबें हैं लेकिन उन्हें प्रबंधन करने के लिए दर्द होता है, बेहतर नहीं कि इसके बोर्ड को संदर्भित करने के लिए एक टुकड़ा हो। लेकिन तब टुकड़ा अपनी चाल उत्पन्न नहीं कर सकता क्योंकि यह बोर्ड की स्थिति को नहीं जानता है। तब टुकड़ा केवल एक डेटा संरचना बन जाता है जो कि टुकड़ा प्रकार और उसकी स्थिति को धारण करता है। फिर आप सभी प्रकार के टुकड़ों के लिए चाल उत्पन्न करने के लिए एक बहुरूपी फ़ंक्शन का उपयोग कर सकते हैं। यह कार्यात्मक प्रोग्रामिंग में पूरी तरह से प्राप्त करने योग्य है लेकिन रनटाइम प्रकार की जांच और अन्य खराब ओओपी प्रथाओं के बिना ओओपी में लगभग असंभव है ... फिर,