Kotlin में Generics: क्यों आवश्यक हैं और उनका उपयोग कैसे करें

Kotlin में Generics का परिचय

Generics (सामान्यीकृत प्रकार) — स्थिर रूप से टाइप की गई प्रोग्रामिंग भाषाओं, जिसमें Kotlin शामिल है, की प्रमुख क्षमताओं में से एक है। ये आपको लचीला, पुन: प्रयोज्य कोड लिखने की अनुमति देते हैं, जो विभिन्न डेटा प्रकारों के साथ काम करता है, साथ ही संकलन चरण में सख्त प्रकार की सुरक्षा बनाए रखता है।

कल्पना करें कि आपको तत्वों की सूची संग्रहीत करने के लिए एक डेटा संरचना बनाने की आवश्यकता है। Generics के बिना, आपको प्रत्येक प्रकार (IntList, StringList, UserList) के लिए अलग-अलग क्लास लिखनी होगी। Generics के साथ, एक क्लास MyList<T> पर्याप्त है, जो किसी भी प्रकार के साथ काम करेगा।

// Generics के बिना — कोड को दोहराना पड़ता हैclass IntList(private val items: MutableList<Int>)class StringList(private val items: MutableList<String>)

// Generics के साथ — सभी प्रकारों के लिए एक क्लासclass GenericList<T>(private val items: MutableList<T>) {    fun add(item: T) { items.add(item) }    fun get(index: Int): T = items[index]}

इस लेख में, हम विस्तार से समझेंगे कि Kotlin में generics कैसे काम करते हैं, उनके सिंटैक्स, उपयोग के विकल्प और कोवेरियंस और कॉन्ट्रावेरियंस जैसी उन्नत अवधारणाओं पर विचार करेंगे।

Generics के साथ काम करने की मूल बातें

सामान्यीकृत क्लास और फंक्शन घोषित करना

सामान्यीकृत क्लास घोषित करने के लिए, क्लास के नाम के बाद कोण कोष्ठक में एक या अधिक प्रकार पैरामीटर निर्दिष्ट करना पर्याप्त है:

class Box<T>(var value: T) {    fun getValue(): T = value    fun setValue(newValue: T) { value = newValue }}

// उपयोगval intBox = Box<Int>(42)val stringBox = Box<String>("Hello")

// Kotlin प्रकार का अनुमान लगा सकता है, इसलिए छोटा लिखा जा सकता हैval anotherBox = Box("Auto type inference")

फंक्शन भी सामान्यीकृत हो सकते हैं। प्रकार पैरामीटर फंक्शन के नाम से पहले निर्दिष्ट किया जाता है:

fun <T> printItem(item: T) {    println("Item: $item")}

fun <T> createPair(first: T, second: T): Pair<T, T> {    return Pair(first, second)}

// उपयोगprintItem(123)printItem("Text")val pair = createPair("A", "B")

प्रकार सीमाएँ (Type Bounds)

कभी-कभी उन प्रकारों को सीमित करने की आवश्यकता होती है जिनका उपयोग generics में किया जा सकता है। इसके लिए : Type कीवर्ड के साथ ऊपरी सीमाएँ (upper bounds) लागू की जाती हैं:

// केवल वे प्रकार जो Comparable को लागू करते हैंfun <T : Comparable<T>> findMax(a: T, b: T): T {    return if (a > b) a else b}

// where के माध्यम से कई सीमाएँfun <T> processItem(item: T)     where T : CharSequence, T : Comparable<T> {    println("Length: ${item.length}")    println("Compared: ${item.compareTo(item)}")}

// उपयोगprintln(findMax(10, 20))        // 20println(findMax("Apple", "Banana")) // "Banana"// findMax(10, "Text") // संकलन त्रुटि!

वेरिएंस: in, out और प्रकार प्रक्षेपण

Generics में सबसे जटिल, लेकिन महत्वपूर्ण विषयों में से एक — वेरिएंस (variance) है। यह निर्धारित करता है कि विरासत के दौरान सामान्यीकृत प्रकार एक-दूसरे से कैसे संबंधित होते हैं।

इनवेरिएंस (डिफ़ॉल्ट)

डिफ़ॉल्ट रूप से, Kotlin में generics इनवेरिएंट होते हैं। इसका मतलब है कि Box<Number> और Box<Int> एक-दूसरे के उपप्रकार नहीं हैं, भले ही Int, Number का उपप्रकार हो:

val intBox: Box<Int> = Box(42)// val numBox: Box<Number> = intBox // संकलन त्रुटि!

कोवेरियंस (out)

मॉडिफायर out प्रकार को कोवेरिएंट बनाता है। इसका मतलब है कि Box<Int>, Box<Number> का उपप्रकार बन जाता है। इसका उपयोग तब किया जाता है जब प्रकार T का उपयोग केवल आउटपुट स्थितियों (रिटर्न वैल्यू) में किया जाता है:

class Producer<out T>(private val item: T) {    fun produce(): T = item  // T केवल आउटपुट पर}