कोटलिन इंटरफेस (उदाहरणों के साथ)

इस लेख में, आप इंटरफेस के बारे में और उदाहरणों की मदद से कोटलिन में इसे कैसे लागू करें, इसके बारे में जानेंगे।

कोटलिन इंटरफेस जावा 8 में इंटरफेस के समान हैं। वे अमूर्त विधियों की परिभाषा के साथ-साथ गैर-अमूर्त विधियों के कार्यान्वयन को शामिल कर सकते हैं। हालाँकि, उनमें कोई भी राज्य नहीं हो सकता है।

मतलब, इंटरफ़ेस में संपत्ति हो सकती है लेकिन उसे अमूर्त करने की आवश्यकता है या एक्सेसर कार्यान्वयन प्रदान करना है।

अनुशंसित पढ़ना: कोटलिन सार वर्ग

कोटलिन में सार कक्षाएं एक महत्वपूर्ण अंतर के साथ इंटरफेस के समान हैं। एक अमूर्त वर्ग के गुणों का सार होना अनिवार्य नहीं है या एक्सेसर कार्यान्वयन प्रदान करना है।

इंटरफ़ेस को कैसे परिभाषित करें?

interfaceकोटलिन में इंटरफेस को परिभाषित करने के लिए कीवर्ड का उपयोग किया जाता है। उदाहरण के लिए,

 इंटरफ़ेस MyInterface (var टेस्ट: स्ट्रिंग // एब्स्ट्रैक्ट प्रॉपर्टी फ़न फू () // एब्स्ट्रैक्ट मेथड फन हेलो () = "हेलो वहाँ" // डिफॉल्ट इम्प्लीमेंटेशन के साथ विधि)

यहाँ,

• एक इंटरफ़ेस MyInterface बनाया गया है।
• इंटरफ़ेस में एक अमूर्त संपत्ति परीक्षण और एक अमूर्त विधि है foo()।
• इंटरफ़ेस में एक गैर-सार पद्धति भी है hello()।

इंटरफ़ेस कैसे लागू करें?

यहां बताया गया है कि कोई वर्ग या ऑब्जेक्ट इंटरफ़ेस को कैसे लागू कर सकता है:

 इंटरफ़ेस MyInterface (वैल टेस्ट: इंट // एब्स्ट्रैक्ट प्रॉपर्टी फन फू) (): स्ट्रिंग // एब्स्ट्रैक्ट मैथड (रिटर्न स्ट्रिंग) फन हेल्लो () (// डिफॉल्ट इम्प्लीमेंटेशन // बॉडी (वैकल्पिक)) क्लास इंटरफेसआईएमपी: माय इंट्रोडक्शन (ओवरराइड) वैल टेस्ट: इंट = 25 ओवरराइड फन फू () = "लोल" // अन्य कोड) 

यहाँ, एक वर्ग InterfaceImp MyInterface इंटरफ़ेस को लागू करता है।

वर्ग foo()इंटरफ़ेस के सार सदस्यों (परीक्षण संपत्ति और विधि) को ओवरराइड करता है।

उदाहरण: इंटरफ़ेस कैसे काम करता है?

 interface MyInterface ( val test: Int fun foo() : String fun hello() ( println("Hello there, pal!") ) ) class InterfaceImp : MyInterface ( override val test: Int = 25 override fun foo() = "Lol" ) fun main(args: Array) ( val obj = InterfaceImp() println("test = $(obj.test)") print("Calling hello(): ") obj.hello() print("Calling and printing foo(): ") println(obj.foo()) )

जब आप प्रोग्राम चलाते हैं, तो आउटपुट होगा:

परीक्षण = 25 कॉलिंग हेलो (): नमस्ते, पाल! कॉलिंग और प्रिंटिंग फू (): लोल

जैसा कि ऊपर उल्लेख किया गया है, एक इंटरफ़ेस में एक संपत्ति भी हो सकती है जो एक्सेसर कार्यान्वयन प्रदान करती है। उदाहरण के लिए,

 interface MyInterface ( // property with implementation val prop: Int get() = 23 ) class InterfaceImp : MyInterface ( // class body ) fun main(args: Array) ( val obj = InterfaceImp() println(obj.prop) )

जब आप प्रोग्राम चलाते हैं, तो आउटपुट होगा:

 २३

यहाँ, प्रोप अमूर्त नहीं है। हालाँकि, यह इंटरफ़ेस के अंदर मान्य है क्योंकि यह एक्सेसर के लिए कार्यान्वयन प्रदान करता है।

हालाँकि, आप val prop: Int = 23इंटरफ़ेस के अंदर ऐसा कुछ नहीं कर सकते ।

एक कक्षा में दो या दो से अधिक इंटरफेस को लागू करना

कोटलिन सच्चे कई उत्तराधिकार की अनुमति नहीं देता है। हालाँकि, एकल वर्ग में दो या दो से अधिक इंटरफेस लागू करना संभव है। उदाहरण के लिए,

 interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMeToo() ( println("From interface B") ) ) // implements two interfaces A and B class Child: A, B fun main(args: Array) ( val obj = Child() obj.callMe() obj.callMeToo() )

जब आप प्रोग्राम चलाते हैं, तो आउटपुट होगा:

 इंटरफ़ेस ए से इंटरफ़ेस बी 

ओवरराइडिंग संघर्षों का समाधान (एकाधिक इंटरफ़ेस)

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

 interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMe() ( println("From interface B") ) ) class Child: A, B fun main(args: Array) ( val obj = Child() obj.callMe() )

यहाँ त्रुटि है:

 त्रुटि: (१४, १) कोटलिन: क्लास must सी ’को पब्लिक ओपन फन कॉलमाइड को ओवरराइड करना चाहिए (): ए में परिभाषित यूनिट क्योंकि यह इसके कई इंटरफ़ेस तरीकों को विरासत में मिला है

इस समस्या को हल करने के लिए, आपको अपना स्वयं का कार्यान्वयन प्रदान करना होगा। ऐसे:

 interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMe() ( println("From interface B") ) ) class C: A, B ( override fun callMe() ( super.callMe() super.callMe() ) ) fun main(args: Array) ( val obj = C() obj.callMe() )

अब जब आप प्रोग्राम चलाते हैं, तो आउटपुट होगा:

 इंटरफ़ेस ए से इंटरफ़ेस बी

यहां, callMe()कक्षा सी में विधि का स्पष्ट कार्यान्वयन प्रदान किया गया है।

वर्ग सी: ए, बी (ओवरराइड फन कॉलमे () (सुपर.कॉलमे () सुपर .callMe) ())

बयान super.callMe()कहता है callMe()इसी वर्ग ए की विधि, कॉल वर्ग की विधि ।super.callMe()callMe()B