Kotlin
इंटरफेस

टिप्पणियों

बुनियादी इंटरफ़ेस

एक कोटलिन इंटरफ़ेस में अमूर्त विधियों की घोषणाएं शामिल हैं, और डिफ़ॉल्ट विधि कार्यान्वयन हालांकि वे राज्य को स्टोर नहीं कर सकते हैं।

interface MyInterface {
    fun bar()
}

यह इंटरफ़ेस अब निम्नानुसार एक वर्ग द्वारा लागू किया जा सकता है:

class Child : MyInterface {
   override fun bar() {
       print("bar() was called")
   }
}

डिफ़ॉल्ट कार्यान्वयन के साथ इंटरफ़ेस

कोटलिन में एक इंटरफ़ेस कार्यों के लिए डिफ़ॉल्ट कार्यान्वयन हो सकता है:

interface MyInterface {
    fun withImplementation() {
      print("withImplementation() was called")
    }
}

इस तरह के इंटरफेस को लागू करने वाले वर्ग उन कार्यों का उपयोग बिना पुन: लागू किए कर सकेंगे

class MyClass: MyInterface {
    // No need to reimplement here
}
val instance = MyClass()
instance.withImplementation()

गुण

डिफ़ॉल्ट कार्यान्वयन संपत्ति पाने वालों और बसने वालों के लिए भी काम करते हैं:

interface MyInterface2 {
    val helloWorld
        get() = "Hello World!"
}

इंटरफ़ेस एक्सेसर्स कार्यान्वयन बैकिंग फ़ील्ड का उपयोग नहीं कर सकते हैं

interface MyInterface3 {
    // this property won't compile!
    var helloWorld: Int
        get() = field
        set(value) { field = value }
}

एकाधिक कार्यान्वयन

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

interface A {
    fun notImplemented()
    fun implementedOnlyInA() { print("only A") }
    fun implementedInBoth() { print("both, A") }
    fun implementedInOne() { print("implemented in A") }
}

interface B {
    fun implementedInBoth() { print("both, B") }
    fun implementedInOne() // only defined
}

class MyClass: A, B {
    override fun notImplemented() { print("Normal implementation") }

    // implementedOnlyInA() can by normally used in instances

    // class needs to define how to use interface functions
    override fun implementedInBoth() {
        super<B>.implementedInBoth()
        super<A>.implementedInBoth()
    }

    // even if there's only one implementation, there multiple definitions
    override fun implementedInOne() {
        super<A>.implementedInOne()
        print("implementedInOne class implementation")
    }
}

गुणों में गुण

आप इंटरफेस में गुणों की घोषणा कर सकते हैं। चूंकि एक इंटरफ़ेस में यह नहीं हो सकता है कि आप केवल एक संपत्ति को सार घोषित कर सकते हैं या एक्सेसर्स के लिए डिफ़ॉल्ट कार्यान्वयन प्रदान कर सकते हैं।

interface MyInterface {
    val property: Int // abstract

    val propertyWithImplementation: String
        get() = "foo"

    fun foo() {
        print(property)
    }
}

class Child : MyInterface {
    override val property: Int = 29
}

डिफ़ॉल्ट कार्यान्वयन के साथ कई इंटरफेस को लागू करते समय संघर्ष

एक से अधिक इंटरफ़ेस को लागू करते समय एक ही नाम के तरीके जिनमें डिफ़ॉल्ट कार्यान्वयन शामिल हैं, यह संकलक के लिए अस्पष्ट है जिसे कार्यान्वयन का उपयोग किया जाना चाहिए। एक संघर्ष के मामले में, डेवलपर को विरोधी पद्धति को ओवरराइड करना चाहिए और एक कस्टम कार्यान्वयन प्रदान करना चाहिए। उस कार्यान्वयन को डिफ़ॉल्ट कार्यान्वयन के लिए प्रतिनिधि के लिए चुना जा सकता है या नहीं।

interface FirstTrait {
    fun foo() { print("first") }
    fun bar()
}

interface SecondTrait {
    fun foo() { print("second") }
    fun bar() { print("bar") }
}

class ClassWithConflict : FirstTrait, SecondTrait {
    override fun foo() {
        super<FirstTrait>.foo()  // delegate to the default implementation of FirstTrait
        super<SecondTrait>.foo() // delegate to the default implementation of SecondTrait
    }

    // function bar() only has a default implementation in one interface and therefore is ok.
}

सुपर कीवर्ड

interface MyInterface {
    fun funcOne() {
        //optional body
        print("Function with default implementation")
    }
}

यदि इंटरफ़ेस में विधि का अपना डिफ़ॉल्ट कार्यान्वयन है, तो हम इसे एक्सेस करने के लिए सुपर कीवर्ड का उपयोग कर सकते हैं।

super.funcOne()