डेल्फी में अंतर को परिभाषित करना और लागू करना

में डेल्फी, "इंटरफ़ेस" के दो अलग-अलग अर्थ हैं। में OOP शब्दजाल, आप एक इंटरफ़ेस के बारे में सोच सकते हैं जिसमें कोई कार्यान्वयन नहीं है। डेल्फी यूनिट में परिभाषा इंटरफ़ेस खंड का उपयोग किसी भी सार्वजनिक कोड के कोड को घोषित करने के लिए किया जाता है जो एक इकाई में दिखाई देते हैं। यह लेख एक OOP परिप्रेक्ष्य से इंटरफेस की व्याख्या करेगा।

यदि आप इस तरह से एक रॉक-सॉलिड एप्लिकेशन बनाने के लिए हैं, तो आपका कोड मेंटेनेंस योग्य, पुन: प्रयोज्य और लचीला हो OOP डेल्फी की प्रकृति आपको अपने मार्ग का पहला 70% चलाने में मदद करेगी। इंटरफेस को परिभाषित करना और उन्हें लागू करना शेष 30% के साथ मदद करेगा।

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

आइए एक उदाहरण इंटरफ़ेस घोषणा पर एक नज़र डालें:

प्रकार
IConfigChanged = इंटरफेस[ '{0D57624C-CDDE-458B-A36C-436AE465B477}']
प्रक्रिया ApplyConfigChange;
समाप्त;

IConfigChanged एक इंटरफ़ेस है। एक इंटरफ़ेस को एक वर्ग की तरह परिभाषित किया गया है, "वर्ग" के बजाय "इंटरफ़ेस" शब्द का उपयोग किया जाता है। इंटरफ़ेस कीवर्ड का अनुसरण करने वाली गाइड वैल्यू का उपयोग कंपाइलर द्वारा इंटरफ़ेस को विशिष्ट रूप से पहचानने के लिए किया जाता है। एक नया GUID मान उत्पन्न करने के लिए, बस डेल्फी आईडीई में Ctrl + Shift + G दबाएं। प्रत्येक इंटरफ़ेस जिसे आप परिभाषित करते हैं, एक अद्वितीय दिशानिर्देश मूल्य की आवश्यकता होती है।

OOP में एक इंटरफ़ेस एक अमूर्तता को परिभाषित करता है - एक वास्तविक वर्ग के लिए एक टेम्पलेट जो इंटरफ़ेस को लागू करेगा - जो इंटरफ़ेस द्वारा परिभाषित तरीकों को लागू करेगा। एक इंटरफ़ेस वास्तव में कुछ भी नहीं करता है, इसमें केवल अन्य (कार्यान्वयन) वर्गों या इंटरफेस के साथ बातचीत के लिए एक हस्ताक्षर है।

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

कक्षाओं के साथ, एक इंटरफ़ेस अन्य इंटरफेस से विरासत में मिल सकता है।

प्रकार
IConfigChangedMore = इंटरफेस(IConfigChanged)
प्रक्रिया ApplyMoreChanges;
समाप्त;

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

इंटरफ़ेस को लागू करने के लिए आपको क्लास स्टेटमेंट में इंटरफ़ेस का नाम जोड़ना होगा, जैसे कि:

प्रकार
TMainForm = कक्षा(TForm, IConfigChanged)
जनता
प्रक्रिया ApplyConfigChange;
समाप्त;

उपरोक्त कोड में "MainForm" नामक एक डेल्फी फॉर्म IConfigChanged इंटरफ़ेस को लागू करता है।

चेतावनी: जब एक वर्ग एक इंटरफ़ेस लागू करता है तो उसे अपने सभी तरीकों और गुणों को लागू करना चाहिए। यदि आप किसी विधि को लागू करने में विफल / भूल जाते हैं (उदाहरण के लिए: ApplyConfigChange) एक संकलन समय त्रुटि "E2003 अघोषित पहचानकर्ता: 'ApplyConfigChange'" घटित होगा।
चेतावनी: यदि आप GUID मान के बिना इंटरफ़ेस निर्दिष्ट करने का प्रयास करते हैं, तो आप प्राप्त करेंगे: "E2086 प्रकार 'IConfigChanged' अभी तक पूरी तरह से परिभाषित नहीं है".

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

कॉन्फ़िगरेशन परिवर्तन के IConfigChanged को लागू करने के लिए अद्यतन किए जाने वाले प्रत्येक प्रपत्र की आवश्यकता होती है। प्रदर्शन स्क्रीन में मामूली रूप से, जब यह अगला कोड बंद करता है तो सुनिश्चित करता है कि सभी IConfigChanged कार्यान्वयन फॉर्म अधिसूचित किए जाते हैं और ApplyConfigChange को कहा जाता है:

प्रक्रिया DoConfigChange ();
वर
cnt: पूर्णांक;
icc: IConfigChanged;
शुरू
के लिये cnt: = 0 सेवा -1 + स्क्रीन। FormCount कर
शुरू
अगर समर्थन करता है (स्क्रीन। प्रपत्र [cnt], IConfigChanged, icc) फिर
आईसीसी। ApplyConfigChange;
समाप्त;
समाप्त;

का समर्थन करता है समारोह (Sysutils.pas में परिभाषित) इंगित करता है कि किसी दिए गए ऑब्जेक्ट या इंटरफ़ेस एक निर्दिष्ट इंटरफ़ेस का समर्थन करते हैं या नहीं। स्क्रीन के माध्यम से कोड पुनरावृत्त होता है। प्रपत्र संग्रह (TScreen वस्तु का) -आवेदन में वर्तमान में प्रदर्शित प्रपत्र। अगर एक रूप स्क्रीन। फार्म [cnt] इंटरफ़ेस का समर्थन करता है, अंतिम पैरामीटर पैरामीटर के लिए इंटरफ़ेस का समर्थन करता है और सही लौटाता है।

इसलिए, यदि फॉर्म IConfigChanged को लागू करता है, तो icc वैरिएबल का उपयोग इंटरफ़ेस के तरीकों को कॉल करने के लिए किया जा सकता है। ध्यान दें, ज़ाहिर है, कि हर फॉर्म हो सकता है ApplyConfigChange प्रक्रिया का अपना अलग कार्यान्वयन.

डेल्फी में आपके द्वारा परिभाषित किसी भी वर्ग को पूर्वज होने की आवश्यकता है। Tobject सभी वस्तुओं और घटकों का अंतिम पूर्वज है। उपरोक्त विचार इंटरफेस पर भी लागू होता है, IInterface सभी इंटरफेस के लिए बेस क्लास है। IInterface 3 विधियों को परिभाषित करता है: QueryInterface, _AddRef और _Release।

इसका मतलब है कि हमारे IConfigChanged में भी वे 3 विधियाँ हैं, लेकिन हमने उन पर अमल नहीं किया है। ऐसा इसलिए है क्योंकि TForm को TComponent से विरासत में मिला है जो पहले से ही आपके लिए IInterface को लागू करता है! जब आप एक क्लास में एक इंटरफ़ेस लागू करना चाहते हैं जो Tobject से इनहेरिट करता है, तो सुनिश्चित करें कि आपकी क्लास TInterfacedObject के बजाय इनहेरिट करती है। चूंकि TInterfacedObject IInterface को लागू करने वाला एक TOBject है। उदाहरण के लिए:

TMyClass = कक्षा(TInterfacedObject, IConfigChanged)
प्रक्रिया ApplyConfigChange;
समाप्त;

अंत में, IUnogn = IInterface। IUnogn COM के लिए है।