Kotlin in Hindi : Collections

  • Introduction to kotlin collections in Hindi
  • Different kotlin collections in Hindi

Introduction to Kotlin Collections

Collections का concept ज्यादातर सभी modern programming languages में introduce किया गया है। Collections आपको data को एक निश्चित तरीके से organize करने की ability provide करते है। कई बार किसी problem को solve करने के लिए data को किसी special तरीके से organize करने की आवश्यकता होती है।

इसका सबसे बेहतरीन उदाहरण Array है। Array भी एक collection ही होता है। इसमें एक type के data items continuous memory locations में store किये जा सकते है। यह उन situations में उपयोगी है जब आप एक ही type के items को एक साथ store करना चाहते है।

इसी प्रकार हर situation के लिए array भी उपयुक्त नहीं हो सकता है। उदाहरण के लिए आप चाहते की duplicate items न store किये जाये और store किये गए items को change नहीं किया जा सके। ऐसे में array को नहीं use किया जा सकता है। इसी प्रकार और भी कई situations हो सकती है जिनमें data को अलग तरीके से organize करने की आवश्यकता होती है।

ऐसी ही आवश्यकताओं को देखते हुए kotlin आपको कुछ built in collections provide करती है जो common operations के लिए उपयोग किये जा सकते है। 

Complex Data Types 

Kotlin में collections composite data types होते है। यानी की इनमे different types के data items को एक साथ store किया जा सकता है। उदाहरण के लिए आप एक collections में एक साथ string और numbers दोनों को store कर सकते है। 

Stores a Group of Data

Collections data types के द्वारा आप data के group को store करते है। Primitive types जैसे की int, double आदि के द्वारा single items को ही store किया जा सकता है।

Mutable and Immutable Collections

Kotlin आपको mutable और immutable दो प्रकार के collections provide करती है। Mutable collections वे होते है जिनके items को change किया जा सकता है और immutable collections वे होते है जिनके items को change नहीं किया जा सकता है।

सभी kotlin collections के mutable और immutable दो versions होते है। आप अपनी आवश्यकता अनुसार किसी भी प्रकार का collection create कर सकते है।

Collections API

Collections के साथ कार्य करने के लिए kotlin आपको एक सम्पूर्ण collection API provide करती है। यह API  kotlin.collections package के रूप में provide की गयी है। इस API में Collection, Iterable, List, Set और Map interfaces define किये गए है। 

इस API में कई standard library functions भी define किये गए है जो collections के साथ कार्य करने के लिए use किये जाते है। 

List

Kotlin आपको List collection provide करती है जो एक list की तरह data items को store करती है। यह Python में available List type जैसा ही है।

Can Have Variable Number of Elements

एक array की length हमेशा fixed होती है। उस length से अधिक items आप array में नहीं add कर सकते है। लेकिन एक List आपको अपनी आवश्यकतानुसार कितने भी elements add करने की ability provide करती है।

Elements Can Be Added And Removed As Well

List के अंदर आप elements को अपनी इच्छानुसार add और remove कर सकते है।

listOf() 

इस function का प्रयोग एक read only list create करने के लिए किया जाता है। यह items को argument के रूप में लेता है। इस प्रकार की list से items को change या remove नहीं किया जा सकता है।

val myList = listOf(“Red”,”Green”,”Blue”)   

mutableListOf() 

यह function एक mutable (read/write) list create करने के लिए use किया जाता है। Mutable list से आप items को remove और change कर सकते है।

val = myMutableList = mutableListOf(“Red”,”Green”,”Blue”)

List Properties

  • Size – List की size return करती है। 

List Functions 

  • contains() – क्या argument के रूप में pass किया गया item list में है?
  • containsAll() – क्या argument के रूप में pass किये गए collection के सभी items इस collection में है?
  • get() – Pass की गयी index से item को return करता है। 
  • indexOf() –  Pass किये गए item की first occurrence position को return करता है। 
  • isEmpty() – True return करता है यदि collection empty है तो। 
  • iterator() – iterator return करता है। 
  • lastIndexOf() – Pass किये गए item की last occurrence index return करता है। 
  • listIterator() – सभी list items के लिए list iterator return करता है। 
  • subList() – Pass की गयी integer starting और ending index positions के बीच से items को return करता है। 

Set

यदि आप चाहते है की आपका data unique और अपिरवर्तनीय हो तो ऐसे में आप set collection का प्रयोग कर सकते है। 

Every Element Has to Be Unique

Set collection unique data items को ही store करता है। इसलिए यह आवश्यक होता है की set को उन्हीं situations में उपयोग किया जाये जब आप unique data के साथ कार्य करना चाहते हों। 

Existing Elements Can Not Be Changed

एक set collection के elements को change नहीं किया जा सकता है। यह feature set को एक secure collection बनाता है। जब आप चाहते है की data को कोई बदल न पाए तो ऐसे में आप set collection का उपयोग कर सकते है। 

Does Not Support Indexing

Set collection indexing को support नहीं करता है। यानि की array की तरह set collection के items को आप indexing के द्वारा access नहीं कर सकते है। 

setOf() 

यह function एक Immutable (read only) set create करने के लिए प्रयोग किया जाता है। इसमें items argument के रूप में pass किये जाते है। इस प्रकार के set से items को remove नहीं किया जा सकता है।

val mySet = setOf(“Apple”,”Orange”,”Banana”)

mutableSetOf() 

इस function का प्रयोग एक mutable set create करने के लिए प्रयोग किया जाता है। एक mutable set collection से आप items को remove कर सकते है।

val myMutableSet = mutableSetOf(“Apple Orange”,”Banana”)

Set Properties 

  • size – Set collection की size return करती है। 

Set Functions 

  • contains 
  • containsAll 
  • isEmpty 
  • iterator 

Map

कई बार ऐसी situation हो सकती है की data आपको key/value pair में available हो। ऐसी situation में data को organize करने के लिए आप kotlin का map collection use कर सकते है। 

Group of Key/Value Pairs

एक Map collection में हर item key और value के pair में store किया जाता है। इसलिए Map collection को key/value pairs का group भी कहा जाता है। 

Key Needs to Be Unique 

Map collection में सभी keys unique होनी चाहिए। हालाँकि values duplicate हो सकती है।

mapOf()

इस function के प्रयोग से आप एक immutable map collection create कर सकते है। इसमें argument के रूप में items को comma से separate करके pass किया जाता है। Key और values को to keyword द्वारा एक साथ map किया जाता है।

val myMap = mapOf(“A” to “Apple”,”B” to “Banana”,”C” to “Cherry”) 

mutableMapOf() 

इस function के द्वारा आप एक mutable map create कर सकते है।

val mutableMapOf(“A” to “Apple”,”B” to “Banana”,”C” to “Cherry”)

Map Properties 

  • entries – Map के सभी items का read only set return करती है। 
  • keys – Map की सभी keys का read only set return करती है। 
  • size – Map collection की size return करती है। 
  • values – Map की सभी values का read only collection return करती है। 

Map Functions

  • containsKey – Map में pass की गयी key होने पर true return करता है। 
  • containsValue – Map में pass की गयी value होने पर true return करता है। 
  • get – Pass की गयी key की value को return करता है। 
  • getOrDefault – या तो pass की गयी key की value return की जाती है नहीं तो default value return की जाती है। 
  • isEmpty – Map के empty होने पर true return करता है। 

Kotlin का collection API बहुत ही large है। यँहा कुछ ही महत्वपूर्ण functions और properties के बारे में बताया गया है।

Previous: Kotlin Packages
Next: Kotlin Ranges

Kotlin in Hindi : Packages

  • Introduction to kotlin packages in Hindi
  • Default kotlin packages in Hindi
  • Importing kotlin packages in Hindi

Introduction to Kotlin Packages

एक package multiple source files (programs) का collection होता है। Package का प्रयोग related code files को organize करने के लिए किया जाता है।

उदाहरण के लिए आप एक ecommerce application create कर रहे है। आप इस application से सम्बंधित network connectivity, payment gateway, user interface और products आदि से सम्बंधित files को एक packages में organize कर सकते है।

Easy to Maintain Code 

Packages के माध्यम से code को maintain करना बहुत सरल होता है। जब packages में files को organize किया जाता है तो उन्हें आसानी से ढूँढा और maintain किया जा सकता है।

यदि files अलग अलग packages में ना होकर एक ही स्थान पर हो तो उन्हें ढूँढना और उपयोग करना बहुत मुश्किल होता है।

Improves Code Reusability

एक package की files को आप किसी भी दूसरी kotlin file में use कर सकते है। ऐसा आप उस package को import करके करते है। Packages के माध्यम से आप एक ही code को कई अलग अलग files में import करके use कर सकते है। इससे आपका समय बचता है और code reusability बढ़ती है। 

No Name Conflict 

एक ही file में same नाम की definitions (variable, function आदि) होने से name conflict create होता है और compiler error generate करता है। लेकिन यदि आप उन files को अलग अलग packages में रखते है तो किसी प्रकार name conflict generate नहीं होता है। 

Defined in the Beginning of File  

Package declaration source file की शुरुआत में किया जाता है। इसके बाद आप जो भी code लिखते है वह उस package में store किया जाता है। किसी भी दूसरी file में उस package को import करके code को use किया जा सकता है। 

Default Package

यदि आप file की शुरुआत में कोई भी package define नहीं करते है तो उस file का code default package में store होता है। Default package का कोई नाम नहीं होता है और उसे आप import नहीं कर सकते है।

package Keyword 

Package declare करने के लिए package keyword का प्रयोग किया जाता है। 

<packageKeyword> <packageName>

आप dot operator का प्रयोग करते हुए subpackage में भी किसी file के code को store कर सकते है।

<packageKeyword> <pacakgeName><.><subPacakgeName>

Default Kotlin Packages

Kotlin में ऐसे भी कुछ packages है जो हर kotlin file में automatically by default import किये जाते है। 

kotlin.*

यह package core functions और types provide करता है जो सभी platforms के लिए एक समान है। 

kotlin.annotations.*

यह package kotlin annotation facility के लिए library support provide करता है। 

kotlin.collections.*

यह package List, Set, Map आदि collection types और extension functions provide करता है। 

kotlin.comparisons.*

यह package Comparator instances create करने के लिए helper functions provide करता है। इससे kotlin 1.1 से include किया गया है। 

kotlin.io.*

यह package files और streams के साथ कार्य करने के लिए IO API provide करता है। 

kotlin.ranges.*

यह package ranges, progressions और related top level और extension functions के लिए support provide करता है। 

kotlin.sequences.*

यह package sequences और sequences के लिए available extension functions को instantiate करने के लिए top level functions provide करता है। 

kotlin.text.*

यह package text और regular expressions के साथ कार्य करने के लिए functions provide करता है। 

Kotlin Platform Specific Packages

kotlin कुछ ऐसे packages provide करती है जो सिर्फ specific platforms के लिए ही प्रयोग किये जाते है। 

java.lang.*

यह package java core library provide करता है। 

kotlin.jvm.*

यह package java platform के लिए functions और annotations provide करता है। 

kotlin.js.*

यह package JavaScript platform के लिए functions और दूसरी API’s provide करता है। 

Importing Kotlin Packages

Packages को import करने के लिए आप import keyword use करते है। Import keyword द्वारा आप classes, functions, properties और enum constants आदि import कर सकते है।

एक complete package को import करने के लिए * का प्रयोग किया जाता है। Compiler को * से यह पता चलता है की आप सम्पूर्ण package import करना चाहते है।

import myPackage.*

आप चाहे तो package में available किसी single definition को भी import कर सकते है।

import myPackage.myFunction

यदि same नाम के दो package होने से name clash हो रहा है तो ऐसे में आप किसी package को दूसरे नाम के रूप में भी import कर सकते है। इसके लिए as keyword का प्रयोग किया जाता है।

import myPackage as xPackage

ऊपर दिए गए statement में myPackage को xPackage के रूप में import किया गया है।

Previous: Kotlin Generics
Next: Kotlin Collections

Kotlin in Hindi : Control Flow

  • Introduction to kotlin control flow in Hindi
  • Kotlin if, when, for and while expressions in Hindi

Introduction to Kotlin Control Flow

कई बार आपको program के execution को control करने की आवश्यकता होती है, जब आप ऐसा करते है तो वह program के flow को control करना कहा जाता है।

उदाहरण के लिए आप चाहते है की program में कुछ statements एक निश्चित condition आने पर execute किये जाएँ और यदि वह condition नहीं आये तो उन statements को execute नहीं किया जाये।

यह program के execution को अपने अनुसार control करना होता है। यह सभी programming languages में किया जाता है।

Control Execution (or Flow) of Program

एक program किस प्रकार execute किया जायेगा यह control करने के लिए kotlin आपको control flow expressions provide करती है। ये expressions आपको अपने मनचाहे तरीके से program को execute करने में मदद करते है।

  • Decision Making
    • if else
    • when
  • Looping
    • for
    • while
    • do-while
  • Jumping
    • break
    • continue

Can be used as Expressions in Kotlin

कई programming languages में इन्हे control flow statements के रूप में भी जाना जाता है। लेकिन kotlin में इन्हे control flow expressions कहा गया है।

इसका कारण यह है की kotlin में इनको expression के रूप में भी आप किसी statement में use कर सकते है और ये values return करते है। यही कारण भी है की kotlin में इन्हे statements ना कहकर expressions कहा गया है।

इनमें से अधिकतर statements या expressions के बारे में आप पहले कई programming languages में पढ़ चुके होंगे। इनमें से when expression आपके लिए नया हो सकता है और for loop भी दूसरी programming languages से अलग है।

If – Else Expression

If else expression if और else keywords के माध्यम से बनता है। इसे आप traditional तरीके से भी use कर सकते है और expression के रूप में भी use कर सकते है।

जब आप इसे expression के रूप में use करते है तो इसके द्वारा कोई एक value return की जाती है जो की expression में use होती है।

if(condition) value1 else value2

जब आप इसे traditional तरीके से use करते है तो condition true और होने पर if part के और condition false होने पर else part के statements execute होते है।

if(condition)
{
    //statements to be executed when condition is true
}
else
{
    //statements to be executed when condition is false
}

Kotlin में ternary operator नहीं है क्योंकि आप if else को expression के रूप में use कर सकते है। 

val a: Int = 10
val b: Int = 20

//Traditional Way

if(a>b)
{
   print(“A is bigger.”)
}
else
{
   print(“B is bigger.”)
}

//As an Expression

max = if (a>b) a else b

print(max+”is Bigger”)

When Expression 

Kotlin में when expression c language में available switch statement की तरह ही है। इससे आप multiple conditions के अनुसार code को execute कर सकते है। इस expression के होने से आपको multiple conditions के लिए multiple if else expressions लिखने की आवश्यकता नहीं होती है।

When expression को भी आप एक expression के रूप में या traditional तरीके से use कर सकते है। जब इसे expression के रूप में use किया जाता है तो जो branch condition को fulfil करती है उसकी value expression की value बन जाती है।

when(branch)
{
   1 ->  //statement to be executed for case or branch 1
   2 -> //statement to be executed for case or branch 2
   else -> {
    //statements to be executed when no case matches.
}

जब when को traditional तरीके से use किया जाता है तो condition को satisfy करने वाली branch के statements execute कर दिए जाते है।

val color: Int = 2
when (color)
{
   1->print(“Red”)
   2->print(“Green”)
   3->print(“Blue”)
   else->{
                print(“No case matched”)
   }
}

जब आप when को expression के रूप में use करते है तो else block define किया जाना अनिवार्य होता है। Else block तब execute होता है जब दी गयी choice किसी भी branch से match नहीं करती है।

जब when को expression के रूप में use किया जाता है तो else block में default value रखी जाती है क्योंकि यदि कोई भी branch match नहीं करती है तो expression में null value आ सकती है। इससे बचने के लिए else block को define किया जाना आवश्यक होता है।

Combine Branch Conditions with Comma

कई branch conditions को एक साथ comma से separate करके combine भी किया जा सकता है। मान लीजिये आप कुछ branches के लिए same ही code define करना चाहते है तो ऐसे में ये उपयोगी होता है। 

Use Arbitrary Expressions as Conditions

Numbers की जगह expressions को भी branch के रूप में use किया जा सकता है। इससे आप कुछ conditions के अनुसार अलग अलग codes को execute कर सकते है।

For Loop 

Kotlin में for loop दूसरी programming languages से अलग है। यह कई programming languages में available foreach loop जैसा है।

Kotlin में for loop उन objects को iterate करता है जो iterator provide करते है।

for(item in collection)
{
     //loop body
}

एक object द्वारा iterator provide किये जाने का अर्थ है की उस object में iterator() function member या extension के रूप में available हो। इसके अलावा iterator() function के return type में next() और hasNext() function available होने चाहिए।

ये तीनो functions items को iterate करने में आवश्यक होते है। इन functions को operator के रूप में mark किया जाना चाहिए।

Numbers की range में iterate करने के लिए range expression use किया जाना चाहिए।

for(item in 1..9)
{
    //loop body
}

एक array को for loop द्वारा इस प्रकार iterate किया जाना चाहिए।

for(item in arr.indices)
{
    println(arr[item])
}

While & Do-while Loop 

Kotlin में while और do-while loop सभी programming languages के जैसे ही है। While loop तब iterate होता है जब तक की उसमे pass की condition true रहती है। जैसे ही condition false होती है while loop terminate हो जाता है।

while(cond)
{
    //statements to be executed until above condition is true
   //increment और decrement
}

While को terminating condition तक पहुँचाने के लिए यह आवश्यक है की उसमे increment या decrement किया जाये।

Do-while loop भी while loop की तरह ही होता है। इनमें फर्क सिर्फ इतना होता है की do-while loop एक बार अवश्य execute होगा ही होगा फिर चाहे condition true हो या false हो। क्योंकि do-while एक exit control loop है।

do
{
    //statements to be executed
    //increment or decrement
}while(cond)

break Label

Loop में break label का प्रयोग loop के execution को रोकने के लिए किया जाता है। Kotlin आपको  break statements को label के साथ define करने की ability provide करती है। यह label सभी प्रकार के loops में प्रयोग किया जाता है।

//other statements

for(item in 1..9)
{
   if(item==3)
   {
       break@startHereLabel
    }
}

//other statements

startHereLabel@

//other statements

जैसे break statement execute होता है loop terminate हो जाता है और execution उस label पर चला जाता है जो break के बाद define किया गया है।

continue Label

एक continue label भी break label के जैसा ही होता है। इनमें फर्क यह है की execute होने पर break for loop को terminate कर देता है और continue current iteration को skip कर देता है। Continue के साथ भी आप labels define कर सकते है जो indicate करते है की execution कँहा से शुरू होना चाहिए। 

for(item in 1..9)
{
    if(item==3)
    {
        continue
    }
}

Previous: Kotlin Variables
Next: Kotlin Classes

Kotlin in Hindi : Generics

  • Introduction to kotlin generics in Hindi
  • Kotlin generic types in Hindi

Introduction to Kotlin Generics

सभी advanced और popular programming languages में generics एक बहुत ही common programming feature है। Java में भी यह feature available है। Java में available ज्यादातर सभी built-in classes, interfaces और collections generic type के है। 

Generics से आपको reliability मिलती है। Generics का concept आपको एक ही code को अलग अलग data type के साथ execute करने की capability provide करता है।

Writing Same Code for Different Types 

यह उन situations में महत्वपूर्ण होता है जब आपको data के type का सही अनुमान न हो और यह उन situations में भी उपयोगी होता है जब एक ही प्रकार के code को अलग अलग types के लिए execute करना हो। 

ऐसे में आप किसी code को generic type का बना सकते है ताकि वह एक particular type से bound ना हो कर किसी भी type के साथ execute किया जा सके। इससे फ़ायदा यह होता है की आपको हर particular data type के लिए अलग से code नहीं लिखना होता है। 

उदाहरण के लिए आप एक addition function बनाते है जो दो numbers को add करता है। यदि आप code में type integer define करते है तो ऐसे में वह function सिर्फ integer numbers के साथ ही execute किया जा सकेगा।  

यदि उस function में double या float type की values pass की जाती है तो वह function execute नहीं होगा और error generate होगी। 

इस situation में आप अलग अलग types के numbers को add करने के लिए अलग अलग functions create करने के लिए मजबूर है। हालाँकि उन सभी functions में एक ही प्रकार का code होगा जो दो numbers को add करता है और वह एक ही प्रकार से कार्य करेगा। 

आप अलग अलग types के लिए function create करेंगे जिससे आपके program का code अधिक हो जायेगा और एक programmer के रूप में आप भी बार बार एक ही code को लिखकर परेशान हो जायेंगे। 

इस situation में आप generic feature को use कर सकते है। इस feature को use करते हुए आप एक generic type का addition function create कर सकते है। यह function add करने के लिए दो number arguments के अलावा एक type भी argument के रूप में लेगा और उसी के अनुसार numbers को add कर देगा। 

उदाहरण के लिए float numbers को add करने के लिए float type argument pass किया जायेगा और integer numbers को add करने के लिए integer type argument pass किया जायेगा। 

Executing Same Code With Different Types

Generic feature को implement करके आप एक ही code को अलग अलग types के data के साथ execute कर सकते है। इससे आपका समय बचता है और program की redability बढ़ती है।

आप ऐसी classes, methods और properties define कर सकते है जिन्हे अलग अलग types के data के साथ प्रयोग किया जा सकता है।

Compile Time Type Safety

Kotlin में generic feature type safety से कोई समझौता नहीं करता है। जैसा की आपको पता है kotlin एक type safe programming language है। इसलिए सभी प्रकार के types को compile time पर ही resolve कर लिया जाता है।

उसी प्रकार generic type के classes, methods और properties को pass किये गए types को भी compile time पर ही resolve कर लिया जाता है।

Defined with Type Parameter

जब आप कोई generic code define करते है जो उसमें type parameter को define करते है और उस code को execute करते समय argument के रूप में एक type pass किया जाता है। 

Type parameters define करने के लिए T का प्रयोग किया जाता है। यह type को दर्शाता है और किसी real type के लिए placeholder का कार्य करता है। T को angular brackets <T> define किया जाता है। इस प्रकार सिर्फ headers में ही किया जाता है बाकी जगह आप इस T को directly type की तरह use कर सकते है। 

Generic Classes

Generic class define करने के लिए आप class header में ही type parameter define करते है। इसके बाद उस type parameter T को constructors और class body में real type की तरह use किया जाता है।

class className <T>
{
    //Use T as a type inside class…
}

Execution के समय जब एक real type pass किया जाता है तो T उस real type के द्वारा replace हो जाता है। एक generic class का object create करते समय भी type को angular brackets में pass करते है।

class myClass <T> (n: T)           //A generic class
{
   
}

val obj: myClass<String> = myClass<String>(5)     //Creating generic class object

Generic Functions

Classes की ही तरह functions को generic define करने के लिए आप function header में <T> type parameter define करते है।

fun <T> functionName(parameters-list) : returnType
{
    //Use T as type in function body
}

जब आप एक generic function को call करते है तो उस समय type argument के रूप में real type pass किया जाता है।

fun <T> myFunction(n: T):T
{
    return n
}

result= myFunction<Int>(5)

Generic Properties

Kotlin में generic properties define करने में समस्या यह होती है की kotlin में properties को initialize किया जाना आवश्यक होता है। क्योंकि generic type define करते समय type unknown रहता है इसलिए property के लिए initializer भी fix नहीं होता है।

var myProperty: T? = Any()

ऐसे में या तो property को Any() के साथ define किया जाए या फिर primary constructor में property को define किया जाये और object create करते समय उसे intialize किया जाये। इससे kotlin compiler किसी प्रकार की error generate नहीं करेगा।

class myClass<T>(val myProeprty: T)
{
     init
     {
           //initialize property here….
     }
}

Variance, Covariance & Contra-variance

जब एक type को किसी sub type या super type को assign किया जाता है तो वह situation variance कहलाती है। Variance अलग अलग programming languages में अलग अलग होता है।

Java में आप एक type को दूसरे type को assign नहीं कर सकते है। Java में generic types में आपस में कोई sub type और super type relationship नहीं है। Java की यह situation in variance कहलाती है।

लेकिन kotlin में ऐसा करना संभव है। Kotlin आपको generic type को किसी sub या super type को assign करने की ability provide करती है। इसके लिए kotlin in और out keyword provide करती है।

Covariance

जब एक generic type को super type को assign किया जाता है तो वह situation covariance कहलाती है। अपने generic code के result को किसी super type के instance से refer करने के लिए आप type parameter को out modifier के साथ define करते है।

class className <out T> (parameter T)
{
      //use T as type
}

Contravariance

जब एक generic type को sub type को assign किया जाता है तो उसे contravariance कहा जाता है। Generic code के result को यदि आप उसके किसी sub type के द्वारा refer करना चाहते है तो इसके लिए आपको type parameter को in modifier के साथ define करना होता है। 

class className <in T> (parameter: T)
{
    //use T as type
}

Previous: Kotlin Inline Classes
Next: Kotlin Packages

Kotlin in Hindi : Inline Classes

  • Introduction to kotlin inline classes in Hindi
  • kotlin inline classes members in Hindi

Introduction to Kotlin Inline Classes

कई बार जब आप बड़े organizational projects पर कार्य करते है तो उनकी requirnement सामान्य applications से अलग होती है। जैसे की हो सकता है की आपको कोई task perform करने के लिए एक type को wrapper में wrap करने की आवश्यकता हो सकती है।

जब ऐसा किया जाता है तो ज्यादातर situations में run time overhead बढ़ जाता है। क्योंकि wrapper के लिए additional heap allocation की आवश्यकता होती है।

यदि छोटी applications की या कम महत्वपूर्ण projects की बात की जाए तो समय ज़्यादा महत्व नहीं रखता है। लेकिन कुछ projects ऐसे होते है जँहा समय धन के बराबर होता है ऐसे में कम से कम समय में task perform करना बहुत आवश्यक होता है।

ऐसी ही situations को handle करने के लिए kotlin में inline classes का concept introduce किया गया है। ये ऐसी classes होती है जिन्हें wrap किये जाने पर भी runtime overhead नहीं बढ़ता है।

Declared Using Inline Modifier

Inline classes को inline modifier से prefix करके declare किया जाता है।

<inline> <class> <class-Name>(single-property-initialization)
{
    //member of inline class
}

Must Have a Single Property Initialized in Primary Constructor

जब आप एक inline class declare करते है तो primary constructor में single property को initialize किया जाना अनिवार्य होता है। 

यानी की जब inline class का instance create किया जायेगा तो primary constructor के द्वारा inline class की property के लिए एक argument pass किया जायेगा। 

inline class myInlineClass(var name: String)
{
    //property and function declaration
}

Runtime के दौरान inline class के instances primary constructor में initialize की गयी single property द्वारा ही represent किये जायेंगे।

var obj = myInlineClass(“Best Hindi Tutorials”)  

असल में एक inline class का object create नहीं होता है। यही कारण है की inline class को यदि किसी wrapper के अंदर भी डाला जाता है तो भी extra runtime overhead नहीं create होता है।

Object में property की value होती है। यानी जँहा भी object को use किया जाता है वँहा पर class का data inline हो जाता है। Normally जब object को use किया जाता है तो class members के बीच calls की प्रक्रिया चलती है। लेकिन inline classes के case में ऐसा नहीं होता है। ये लगभग inline functions जैसा ही है।

Inline Classes are Experimental

Inline classes अभी तक experimental है। यानी की इनका real production में use नहीं किया गया है। इन पर experiments किये जा रहे है और जल्दी ही इन्हें production में भी use किया जाने लगेगा। 

Kotlin Inline Class Members

एक kotlin inline class में normal properties और functions declare किये जा सकते है। लेकिन कुछ ऐसे members है जो kotlin inline classes में नहीं declare किये जा सकते है। 

Can Not Have Init Blocks 

एक inline class के अंदर आप init block नहीं define कर सकते है। क्योंकि inline class में primary constructor में एक single property को initialize करना अनिवार्य होता है।

Can Not Have Inner Classes

एक inline class में init block के अलावा आप inner class भी नहीं define कर सकते है।

Inline Class Properties Can Not Have Backing Fields

Inline class में define की गयी properties का कोई backing field kotlin compiler द्वारा automatically नहीं generate किया जाता है।

Can Not Inherit a Class

एक inline class किसी interface को implement कर सकती है। लेकिन एक inline class किसी दूसरी class को inherit नहीं कर सकती है। 

Representation of Kotlin Inline Classes

Compiler हर inline class के लिए wrapper create करता है। लेकिन ज्यादातर cases में underlying या जो real type है वही use किया जाता है।

उदाहरण के लिए int एक underlying type है और ज्यादातर इसे ही use किया जाता है। Integer को int का wrapper कहा जाता है और कई cases में इसे use करना अनिवार्य होता है।

जब inline class को किसी दूसरे type के रूप में use किया जाता है तो compiler उस class का wrapper use करता है। इस process को boxing कहा जाता है।

जब inline class स्वयं के type के रूप में use की जाती है तो wrapper को remove कर दिया जाता है और underlying type को use किया जाता है। यह process unboxing कहलाती है।

उदाहरण के लिए यदि आप एक generic function में inline class object use करते है तो boxing process perform होगी। क्योंकि inline class को दूसरे type (generic type) के रूप में use किया जा रहा है।

Previous: Kotlin Enum Classes
Next: Kotlin Generics

Kotlin in Hindi : Enum Classes

  • Introduction to kotlin enum classes in Hindi
  • Working with kotlin enum classes in Hindi

Introduction to Kotlin Enum Classes

यदि आप enums के बारे में java में पहले पढ़ चुके है तो में आपको बताना चाहूँगा की kotlin में enums classes के रूप में implement किये जाते है। ऐसी classes को enum classes कहा जाता है।

Type-safe Enums

Kotlin में enum classes का प्रमुख उद्देश्य type-safe enums implement करना है। इसका अर्थ है की kotlin enums को किसी दूसरे type को नहीं assign किया जा सकता है।

Defined Using enum Keyword

Kotlin में enum classes को enum keyword के साथ define किया जाता है। 

<enum> <class> <enum-Class-Name>
{
      //enum constants here….
}

Constants are Objects

जैसा की आपको पता है enum types में constants define किये जाते है जो उनकी predefined values होती है। Kotlin enum classes में भी constants define किये जाते है। इन्हें comma से separate करके लिखा जाता है। एक enum class में define किये गए सभी constants उस enum class के objects होते है। 

enum class fruits
{
    Apple, Guava, Banana
}

Constants Can Be Initialized

Enum classes के अंदर आप constants को initialize भी कर सकते है। इसके लिए kotlin name के बाद round brackets में उनकी values define की जाती है।

enum class fruits
{
   Apple(Red)
   Guava(Green)
   Banana(Yellow)
}

Can Define Other Members

एक enum class किसी normal class की तरह constants के अलावा members भी define कर सकती है। ये members constants से semicolon द्वारा separate करके define किये जाने चाहिए। 

enum class fruits
{
     Apple(Red),
     Guava(Green),
     Banana(Yellow);

     //define other members here….
}

Constants Can Declare Anonymous Class

Enum classes में define किये जाने वाले constants खुद की anonymous classes define कर सकते है। Anonymous class के अंदर constants खुद के members define कर सकते है, इसके अलावा वे enum class के members को भी override कर सकते है।

enum class fruits
{

     //members of enum class

      Apple{
           //define members here
           //override members of enum class
      }

      Guava{

      }

      Banana{

      }
}

Can Not Define Nested Types

Enum classes के अंदर nested types नहीं define किये जा सकते है। हालाँकि आप inner classes एक enum class के अंदर define कर सकते है।

Can Implement an Interface

एक enum class किसी दूसरी class को inherit नहीं कर सकती है। हालाँकि enum classes interfaces को implement कर सकती है। 

Implement किये जाने वाले interface के members की या तो एक ही common definition constant anonymous classes के बाहर members की तरह provide की जा सकती है। 

इसके अलावा हर constant की anonymous classes के अंदर भी interface के members को separately implement किया जा सकता है। यदि आप एक common implementation नहीं provide करते है तो सभी constants की anonymous classes द्वारा interface के member का implementation provide करना अनिवार्य हो जाता है। 

Methods of Kotlin Enum Classes

Kotlin enum classes के साथ programmers के लिए कुछ methods available होते है। ये methods enum classes के constants को list और access करने के लिए प्रयोग किये जाते है। 

valueOf(name)

यह method किसी constant की value को access करने के लिए use किया जाता है। इस method में argument के रूप में उस constant का नाम pass किया जाता है। यदि pass किया गया name enum class के किसी constant से match नहीं होता है तो runtime exception generate होती है। 

values()

यह method एक enum class के सभी constants को array के रूप return करता है जिनको for loop द्वारा iterate करके access किया जा सकता है। 

Properties of Kotlin Enum Class Objects

एक enum class के हर object के साथ कुछ properties भी available होती है जो उस object के बारे information प्रदान करती है। 

name

यह property enum class के किसी constant का नाम store करती है। 

ordinal 

ये property किसी constant की position store करती है।

Previous: Kotlin Nested and Inner Classes
Next: Kotlin Inline Classes

Kotlin in Hindi : Nested and Inner Classes

  • Introduction to kotlin nested classes in Hindi
  • Creating kotlin inner classes in Hindi 
  • Kotlin anonymous inner classes in Hindi

Introduction to Kotlin Nested Classes

Kotlin आपको एक class के अंदर दूसरी class create करने की ability provide करती है। ऐसी classes जो दूसरी classes के अंदर create की जाती है nested classes कहलाती है।

class outerClass     //Outer Class
{
       //Members of outerclass

       class nestedClass       //Nested Class
       {
              //Members of nested class
       }
}

Can Not Access Members of Outer Class

हालाँकि nested classes दूसरी class के अंदर define की जाती है लेकिन ये उस class से independent होती है। उदाहरण के लिए एक nested class के अंदर आप outer class के members (properties, functions) को access नहीं कर सकते है।

class outerClass
{
    var age: Int = 90

    class nestedClass
    {
          println(age)   //Wrong, Can not access outer class member in nested class
    }
}

एक nested class के members को access करने के लिए objects का प्रयोग नहीं किया जाता है। बल्कि outer class के नाम के द्वारा ही nested class के members को access किया जाता है।

class outerClass    //Outer Class
{
    class nestedClass     //Nested Class
    {
         fun printMessage()
         {
             println(“Hello reader, You are learning about kotlin nested classes.”)
         }
    }
}

fun main(args: Array<String>)
{
    outerClass().nestedClass().printMessage() //Access nested class member
}

Kotlin Inner Classes

Kotlin आपको inner classes define करने की भी ability provide करती है। कई बार programmers nested और inner classes के बीच confuse हो जाते है क्योंकि nested classes की ही तरह inner classes भी किसी दूसरी class के अंदर define की जाती है।

लेकिन ऐसा बिलकुल भी नहीं nested और inner classes में कई महत्वपूर्ण differences पाए जाते है।

Defined Using inner Keyword

Kotlin में inner classes को define करने के लिए class declaration से पूर्व inner keyword prefix करने की आवश्यकता होती है।

class outerClass    //outer class
{

    //members of outer class 

    inner myInnerClass    //inner class defined using inner keyword
    {
          //members of inner class
    }
}

Access Members of Outer Class 

Kotlin nested classes और inner classes के बीच जो दूसरा महत्वपूर्ण difference है वह यह है की आप एक inner class के अंदर outer class के members को access कर सकते है। लेकिन एक nested class में उसकी outer class के members को access करना possible नहीं होता है।

class outerClass        //outer class
{
      //members of outer class

     inner class myInnerClass   //inner class
     {
          //members of inner class
         //Access members of outer class here
     }
}

एक Inner class के members को access करने के लिए आप उसके object create नहीं करते है बल्कि inner class के members को भी nested class के members की ही तरह outer class के नाम के साथ access किया जा सकता है।

class outerClass
{
     var message: String = “Hello Reader”
 
    inner class myInnerClass
    {
         fun display()
         {
             println(message)
         }
    }
}

fun main(args: Array<String>)
{
    outerClass.myInnerClass.display()
}

Carry a Reference to An Object of Outer Class

Inner classes के बारे में एक और महत्वपूर्ण बात यह है की एक inner class outer class के object का reference hold करती है। 

Kotlin Anonymous Inner Classes

कई बार कुछ ऐसे interfaces होते है जिनमें एक ही method होता है लेकिन उन्हें implement करना अनिवार्य होता है। ऐसे interfaces को java में functional interfaces कहा जाता है।

एक functional interface को implement करने के लिए आप class के अंदर उसके method की definition provide करते है। क्योंकि एक interface का object create करके आप उसके members को access नहीं कर सकते है। 

Kotlin आपको anonymous inner class का concept provide करती है। Anonymous inner class को object expression के माध्यम से create किया जाता है।

Anonymous class के द्वारा आप एक functional interface को anonymously implement कर सकते है। 

interface myInterface     //Functional Interface
{
     fun printMessage()
}

fun main(args: Array<String>)
{
    var obj : myInterface = Object : MyInterface    //Anonymous Inner Class
    {
         override fun printMessage()
         {
              println(“Hello Reader from Anonymous Inner Class”)
         }
    }
}

Previous: Kotlin Sealed Classes
Next: Kotlin Enum Classes

Kotlin in Hindi : Sealed Classes

  • Introduction to kotlin sealed classes in Hindi
  • Defining kotlin sealed classes in Hindi

Introduction to Kotlin Sealed Classes 

Kotlin में sealed classes language feature है। यह concept java में available नहीं है। Sealed classes restricted type (class) hierarchies को represent करने के लिए use की जाती है।

यदि आपने enum types के बारे में पहले से पढ़ा हुआ है तो आप इसे आसानी से समझ पाएंगे। जब आप एक enum type define करते है तो उसके साथ values का एक set भी define करते है।

इसके बाद जब भी enum type का variable create करते है तब उन्हीं define की गयी values में से कोई एक आप उस variable को assign कर सकते है। Enum type में define की गयी values के set के अलावा आप कोई भी दूसरी value उस variable को assign नहीं कर सकते है।

Limited Types Set for a Value

Sealed classes के साथ भी लगभग enum types जैसा ही है। Sealed class में आप values का set नहीं create करते है बल्कि types (classes) का set create करते है। ऐसा आप sealed classes की subclasses define करके करते है।

Sealed classes बहुत ही उपयोगी होती है। उदाहरण के लिए आपने एक function define किया है। आप चाहते है की इस function में pass की जाने वाली value कुछ निश्चित types में से एक की होनी चाहिए।

ऐसे में आप एक sealed class create कर सकते है और जिन types की value आप function में pass करना चाहते है उन्हें sealed classes की subclass के रूप में define कर सकते है।

इसके बाद आप function में sealed class के object को parameter के रूप में pass कर सकते है और function के अंदर sealed class में define किये गए type set में से कोई भी type use कर सकते है।

यदि आसान शब्दों में कहा जाये तो ऐसी situations जब आप एक value को कुछ निश्चित types की होने के लिए bound करना चाहते हो तो आप sealed classes का प्रयोग कर सकते है।

जिन values को type के रूप में sealed class assign की जाती है उन values का type सिर्फ वे ही classes हो सकती है जो sealed class के अंदर subclasses के रूप में define की गयी है।

Subclasses Must be Declared In The Same File

Sealed classes की subclasses उसी file में declare की जानी चाहिए जिसमें sealed class को define किया गया है। हालाँकि sealed classes की subclasses को inherit करने वाली classes (sealed classes की indirect inheritors) कँही भी define की जा सकती है।

Subclass of Sealed Classes Can Have Many Instances

Sealed classes और enums में एक और महत्वपूर्ण difference होता है। Enum types में define किया गया हर constant एक single instance होता है।

लेकिन sealed classes की subclasses के multiple instances create किये जा सकते है।

Sealed Classes are Abstract 

Sealed classes abstract होती है। इसलिए sealed classes के आप directly instances नहीं create कर सकते है। हालाँकि sealed classes की subclasses के आप कितने भी instances create कर सकते है।

Sealed classes में आप abstract members भी define कर सकते है।

Non-Private Constructor

Sealed classes के लिए आप non-private constructors भी define कर सकते है। By default एक sealed class का constructor private ही होता है।

Using with When Expression

Sealed classes को when expression में भी use किया जा सकता है। जब इन्हें when expression में use करते है तो आपको else part define करने की आवश्यकता नहीं होती है। क्योंकि sealed classes आपको एक when expression के सभी cases cover करने की ability provide करती है। 

Defining Kotlin Sealed Classes

Sealed classes को define करना बहुत ही आसान है। यदि आप कोई abstract members नहीं define कर रहे है तो आप एक single line में ही sealed class को define कर सकते है।

Prefix Sealed Modifier

Sealed class define करने के लिए आप class declaration से पूर्व sealed modifier define करते है। 

<sealed> <class> <sealed-class-Name>

एक sealed class को inherit करने के लिए आप normal classes की ही तरह colon का प्रयोग करते है।

<class> <class-Name> : <sealed-class-Name>:<sealed-class-constructor>()

Example of Sealed Classes

sealed class Expr
data class Const(val number: Double):Expr()
data class Sum(val e1: Expr, val e2: Expr): Expr()
object NotANumber: Expr()
fun eval(expr: Expr): Double = when(expr){
is Const ->expr.number
is Sum -> eval(expr.e1)+eval(expr.e2)
NotANumber -> Double.NaN
}

Previous: Kotlin Interfaces
Next: Kotlin Nested and Inner Classes

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

Kotlin in Hindi : Extensions

  • Introduction to kotlin extensions in Hindi
  • Kotlin extension functions in Hindi
  • Kotlin extension properties in Hindi

Introduction to Kotlin Extensions

Kotlin आपको किसी type (class) के साथ additional functionality attach करने की ability provide करती है। ये functionalities type (class) का part नहीं होती है। इन्हे अलग से declare किया जाता है। इन functionalities को extensions के नाम से जाना जाता है।

Functions और properties को आप extensions के रूप में declare कर सकते है। Extensions के द्वारा आप किसी class की ability को extend कर पाते है। Extensions declare करने के लिए आपको class को inherit करने की आवश्यकता नहीं होती है।

Resolved Statically

Extensions के बारे में एक महत्वपूर्ण बात यह है की ये statically resolved होते है। यानी की जिस type के साथ आपने compile time पर expression define किया है उसी type के अनुसार extension execute होगा। इससे कोई फर्क नहीं पड़ता है की run time पर कौनसा type use किया गया है। 

Can be defined with a Nullable Type

Extension को nullable type के साथ भी define किया जा सकता है। ऐसे extensions को null value वाले objects के साथ भी execute किया जा सकता है

Kotlin Extension Functions

एक extension function को आप normal function की तरह ही define करते है। इनमें फर्क सिर्फ इतना होता है की extension function declare करते समय आप function के नाम से पूर्व उस class का नाम define करते है जिसके लिए extension function आप define कर रहे है।

ऐसी classes को receiver type (class) कहा जाता है। इन्हे dot (.) operator के द्वारा class से पहले prefix किया जाता है।  

fun <receiver-Type><.><function-Name>(parameters list)
{
     //extension function body

This Keyword 

यदि आप extension function में से receiver type को refer करना चाहते है तो इसके लिए आप this keyword का प्रयोग करते है। यह keyword receiver type को represent करता है।

Example of Extension Function

class myClass
{
     var num: Int = 40

     fun display()
     {
          println(num);
     }
}

fun myClass.square()
{
    println(this.num*2)
}

fun main(args: Array<String>)
{
   val obj = myClass()
   obj.display()
   obj.square()

40
80

Kotlin Extension Properties

Extension functions की ही तरह आप extension properties भी define कर सकते है। 

<var> or <val> <receiver-Type><.><property-Name><:><Type>

Can Not Initialize Extension Property

एक extension property को initialize नहीं किया जा सकता है। ऐसा इसलिए होता है क्योंकि extensions किसी type को modify नहीं करते है। Extension सिर्फ उस class के object द्वारा execute किये जा सकते है, वे उस type के member नहीं होते है। 

Explicit Getters and Setters

हालाँकि एक extension property को initialize नहीं किया जा सकता है लेकिन आप उसके लिए custom getters और setters define कर सकते है। 

<var> or <val> <receiver-Type><.><property-Name><:><Type>
<getters>
<setters>

Scope of Extensions

Generally extensions को top level elements जैसे की class, function और interface आदि की तरह top level पर define किया जाता है। एक package के अंदर define किये गए extensions को आप आसानी से उस package में कँही भी use कर सकते है। 

यदि extensions किसी दूसरे package में define है तो उन्हें use करने के लिए आपको उन्हें import करना होगा। जिस प्रकार java में अलग अलग packages को import किया जाता है उसी प्रकार यँहा पर extensions को import करते है। 

import <package-Name> <extension-Name>

//use extension in current file

Define Extensions as Members

किसी एक class का extension function आप किसी दूसरी class के member के रूप में भी define कर सकते है। मान लीजिये A और B दो classes है। आप B class के लिए extension function A class के अंदर define कर सकते है।

इस situation में A class का object dispatch receiver कहलाता है और B class का object extension receiver कहलाता है।

class A
{
      fun normalFunction()
      {
          //Function body
      }
}

class B
{
     fun anotherNormalFunction()
     {
         //Function body
     }

     fun A.extFunction(parameters-list)
     {
           extension function body
     }
}

किसी class के अंदर declare किये गए extension functions को open decare करके subclass में override भी किया जा सकता है।

Visibility of Extensions 

एक extension function या property स्वयं के receiver type के members को नहीं access कर सकता है। लेकिन यदि वह स्वयं के receiver type के अंदर ही define किया गया है तो वह receiver type के members को access करता है।

एक top level पर define किया गया extension बाकी दूसरे top level members को access कर सकता है।

Previous: Kotlin Delegated Properties
Next: Kotlin Interfaces