Kotlin in Hindi : Interfaces

  • Introduction to kotlin interfaces in Hindi
  • Implementing kotlin interfaces in Hindi
  • Example of kotlin interfaces in Hindi

Introduction to Kotlin Interfaces

एक interface abstract type होता है जो classes को एक certain behaviour implement करने के लिए बाध्य करता है।

Abstract types ऐसे types होते है जिनके object नहीं create किये जा सकते है और जिन्हें मुख्यतः दूसरी classes द्वारा inherit करने के लिए ही declare किया जाता है। जैसे की abstract classes भी abstract type होती है।

जब एक class किसी interface को implement करती है तो उसके लिए interface में define किये गए सभी functions को implement करना अनिवार्य होता है।

Can Contain Declarations for Abstract Methods

Kotlin interfaces में आप abstract methods declare कर सकते है। ये वो methods होते है जिनकी definition interface को implement करने वाली class provide करती है। Kotlin interfaces में declare किया गया एक method by default abstract ही होता है।

Can Contain Definition of Normal Methods

Abstract methods को declare करने के अलावा kotlin interfaces में आप normal methods को भी define कर सकते है। इन methods की body होती है और implement करने वाली class के लिए इनकी definition provide करना अनिवार्य नहीं होता है। 

Interface को implement करने वाली class सिर्फ abstract declarations (जिन methods की body नहीं होती है) के लिए ही definition provide करती है। 

Can Not Store State

अब आप सोच रहे होंगे की यदि kotlin interfaces में normal methods भी implement किये जा सकते है तो interfaces और abstract classes में क्या difference हुआ?

Kotlin interfaces और abstract classes में सबसे महत्वपूर्ण difference यह है की interfaces में आप किसी object की state नहीं store कर सकते है। 

interface keyword

Kotlin में interface declare करने के लिए interface keyword का प्रयोग किया जाता है।

interface <myInterface>
{
     fun <absfun-Name>();   //Abstract function

     fun <normfun-Name>()   //Normal Function
     {
         
     }
}

override Keyword

Interface को implement करते समय जब आप method की definition provide करते है तो method को define करने से पूर्व आप उसे override keyword से prefix करते है।

class <myClass> : <myInterface>
{
      override fun absfun-Name()
      {
             //Provide definition
      }

      //use normal function normally
}

Implement More Than One Interface

एक class एक साथ एक से अधिक interfaces को भी implement कर सकती है। इसके लिए आप interfaces को comma से separate करके लिखते है।

class <myClass> : <myInterface1>, <myInterface2>,….<myInterfaceN>
{

}

Interface Properties

Kotlin interfaces में आप properties भी define कर सकते है। एक property को interface में define करते समय या तो आप उसे abstract define कर सकते है।

Abstract define की गयी properties को interfaces में initialize नहीं किया जाता है इनके लिए initializer interface को implement करने वाली class provide करती है।

interface <myInterface>
{
     <var> or <val> <propertyName><:> <Type>  //Abstract Property

     <var> or <val> <propertyName><:> <Type>  //Normal Property
     <getter>
     <setter>
}

यदि आप property को abstract define नहीं करते है तो interface में normal property define करने के लिए आपको उसके getters और setters implement करना अनिवार्य होता है।

Functions की ही तरह abstract properties को implement करते समय उन्हें override keyword से prefix किया जाता है।

class <myClass> : <interfaceName>
{
     override <val> or <var> <propertyName><:><Type> = <Initializer>
}

एक बात आपको ध्यान रखनी चाहिए की जिन properties को आप interface में define करते है उनके लिए कोई backing field नहीं हो सकता है। इसलिए जिन properties को interfaces में define किया जाता है वे backing fields को refer नहीं करती है। 

Inheriting Interfaces

Kotlin में एक interface दूसरे interface को भी implement कर सकता है। ऐसे interfaces में normal functions की definition interfaces स्वयं provide करते है और abstract members की definition उन्हें implement करने वाली class provide करती है। 

interface A
{
      //abstract functions
     //normal functions
}

interface B : A
{
     //abstract functions
    //normal functions
}

class myClass : B
{
     //Provide definition for abstract methods of interfaces A and B
     //Use normal functions of interfaces A and B
}

जब एक class किसी derived interface को implement करती है तो वह उस interface और उसके parent interface दोनों के abstract members का implementation provide करती है।

Previous: Kotlin Extensions
Next: Kotlin Sealed Classes