जेनेरिक और प्रकार पैरामीटर
प्रकार-सुरक्षा के साथ पुनः उपयोग योग्य घटक बनाने के लिए जेनेरिक क्लास और विधियाँ लिखना समझें।
जेनेरिक और प्रकार पैरामीटर, CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का एक निःशुल्क पाठ है। यह 3 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 3 पाठ शामिल हैं।
जेनेरिक क्या होते हैं
कल्पना कीजिए कि आपको ऐसा कंटेनर बनाना है जिसमें किसी भी प्रकार की वस्तु रखी जा सके—जैसे String, Int या आपकी बनाई हुई कोई वस्तु। जेनेरिक के बिना, आपको प्रत्येक प्रकार के लिए अलग कंटेनर लिखना पड़ता, जिससे कोड दोहराया जाता, या फिर Any जैसे बहुत व्यापक प्रकार का उपयोग करना पड़ता।
जेनेरिक आपको ऐसा लचीला और पुनः उपयोग योग्य कोड लिखने देते हैं जो विभिन्न डेटा प्रकारों के साथ काम करता है और संकलन के समय भी टाइप सुरक्षा बनाए रखता है। यह एक ऐसे खाके जैसा है जिसमें बाद में अलग-अलग सामग्री लगाई जा सकती है!
`Any` प्रकार का जाल
प्रकारों के स्थान पर Any का उपयोग करने से समस्याएँ पैदा हो सकती हैं। इससे आप कोई भी चीज़ संग्रहीत तो कर सकते हैं, लेकिन उसकी विशिष्ट प्रकार-सूचना खो जाती है। इसका अर्थ है कि आपको अक्सर वस्तु को उसके मूल प्रकार में वापस कास्ट करना पड़ता है। यदि कास्ट गलत हो, तो इससे त्रुटियाँ हो सकती हैं और प्रोग्राम चलते समय क्रैश भी हो सकता है।
इस उदाहरण को चलाकर संभावित समस्याओं पर विचार करें:
class ItemHolder(val item: Any)
object Main {
def main(args: Array[String]): Unit = {
val stringHolder = new ItemHolder("Hello Scala")
val numberHolder = new ItemHolder(123)
// We need to cast, and it's unsafe if we get it wrong
val retrievedString = stringHolder.item.asInstanceOf[String]
println(s"Retrieved String: $retrievedString")
// If we uncomment the line below, it compiles but will crash at runtime!
// val wrongType = numberHolder.item.asInstanceOf[String]
// println(s"Wrong Type: $wrongType")
}
}टाइप पैरामीटर का परिचय
जेनेरिक, Any प्रकार के जाल को टाइप पैरामीटर के माध्यम से हल करते हैं। ये वास्तविक प्रकारों के लिए स्थानधारक होते हैं, जिन्हें आप किसी क्लास का उदाहरण बनाते या किसी मेथड को कॉल करते समय निर्दिष्ट करते हैं।
स्काला में, टाइप पैरामीटर क्लास या मेथड के नाम के बाद वर्ग कोष्ठकों ([]) में लिखे जाते हैं। आम तौर पर इनके लिए T, A, B जैसे बड़े अक्षरों का उपयोग किया जाता है। उदाहरण के लिए, class Box[T] एक जेनेरिक क्लास Box घोषित करता है, जो एक टाइप पैरामीटर T लेती है।
जेनेरिक Box बनाना
आइए Box नाम की एक सरल जेनेरिक क्लास बनाएँ, जिसमें किसी भी प्रकार की सामग्री रखी जा सके। ध्यान दें कि क्लास की परिभाषा में सामग्री के प्रकार को दर्शाने के लिए T का बार-बार उपयोग किया गया है।
इससे हम स्ट्रिंग, पूर्णांक या किसी भी अन्य प्रकार के लिए अलग-अलग क्लास लिखे बिना बॉक्स बना सकते हैं।
class Box[T](val content: T) {
def get: T = content
override def toString: String = s"Box($content)"
}
object Main {
def main(args: Array[String]): Unit = {
val stringBox = new Box("Scala is fun!")
val intBox = new Box(42)
val booleanBox = new Box(true)
println(stringBox)
println(intBox)
println(booleanBox)
}
}जेनेरिक के साथ टाइप सुरक्षा
जेनेरिक का सबसे बड़ा लाभ संकलन-समय टाइप सुरक्षा है। जब आप Box[String] बनाते हैं, तो कंपाइलर जानता है कि इसमें केवल स्ट्रिंग होनी चाहिए। यदि आप इसमें पूर्णांक रखने या इसे पूर्णांक के रूप में प्राप्त करने का प्रयास करते हैं, तो कंपाइलर तुरंत त्रुटि पकड़ लेगा।
इससे Any जैसे कम टाइप-सुरक्षित तरीकों से होने वाली कई सामान्य रनटाइम त्रुटियाँ रोकी जाती हैं।
class Box[T](val content: T) {
def get: T = content
}
object Main {
def main(args: Array[String]): Unit = {
val myStringBox: Box[String] = new Box("CoddyKit")
val myIntBox: Box[Int] = new Box(100)
// This works, type is String
val s: String = myStringBox.get
println(s"String from box: $s")
// This works, type is Int
val i: Int = myIntBox.get
println(s"Int from box: $i")
// The compiler prevents this line from compiling:
// val wrong: String = myIntBox.get // Type mismatch error!
}
}मेथड के लिए भी जेनेरिक!
क्लास की तरह, अलग-अलग मेथड भी जेनेरिक हो सकते हैं। एक जेनेरिक मेथड ऐसे टाइप पैरामीटर ले सकता है जो उसी मेथड तक सीमित होते हैं। इससे पूरी क्लास को जेनेरिक बनाए बिना मेथड अलग-अलग प्रकारों पर काम कर सकता है।
यह तब उपयोगी होता है जब कोई विशेष क्रिया विभिन्न प्रकारों पर लागू की जा सकती हो, लेकिन क्लास स्वयं जेनेरिक कंटेनर न हो।
लचीला `printPair` मेथड
यहाँ जेनेरिक मेथड printPair का एक उदाहरण है। यह दो टाइप पैरामीटर, A और B, लेता है, जिससे यह किन्हीं भी दो प्रकारों की जोड़ी प्रिंट कर सकता है। ध्यान दें कि टाइप पैरामीटर मेथड के नाम के ठीक बाद घोषित किए गए हैं।
इससे मेथड अलग-अलग डेटा संयोजनों के लिए बहुत आसानी से पुनः उपयोग किया जा सकता है।
object Util {
def printPair[A, B](first: A, second: B): Unit = {
println(s"Pair: ($first, $second)")
println(s"Type of first: ${first.getClass.getName}")
println(s"Type of second: ${second.getClass.getName}")
}
}
object Main {
def main(args: Array[String]): Unit = {
Util.printPair("Hello", 123)
Util.printPair(true, List(1, 2, 3))
Util.printPair(4.5, 'C')
}
}स्मार्ट टाइप अनुमान
स्काला की शक्तिशाली सुविधाओं में से एक है टाइप अनुमान। जेनेरिक क्लास या मेथड का उपयोग करते समय आपको अक्सर टाइप पैरामीटर स्पष्ट रूप से बताने की आवश्यकता नहीं होती। आपके द्वारा दिए गए आर्ग्युमेंट के आधार पर स्काला का कंपाइलर उन्हें समझने में सक्षम होता है।
इससे टाइप सुरक्षा से समझौता किए बिना आपका कोड छोटा और पढ़ने में आसान हो जाता है।
class Container[T](val item: T) {
def getItem: T = item
}
object Main {
def main(args: Array[String]): Unit = {
// Scala infers T as String
val stringContainer = new Container("Inferred String")
println(s"Content: ${stringContainer.getItem}, Type: ${stringContainer.getItem.getClass.getName}")
// Scala infers T as Double
val doubleContainer = new Container(3.14)
println(s"Content: ${doubleContainer.getItem}, Type: ${doubleContainer.getItem.getClass.getName}")
// You can also specify explicitly, but often not needed
val explicitIntContainer: Container[Int] = new Container(500)
println(s"Content: ${explicitIntContainer.getItem}, Type: ${explicitIntContainer.getItem.getClass.getName}")
}
}बाउंड की सहायता से जेनेरिक प्रकारों को सीमित करना
कभी-कभी आप चाहते हैं कि कोई जेनेरिक क्लास या मेथड केवल उन प्रकारों के साथ काम करे जिनमें कुछ विशेष क्षमताएँ हों। उदाहरण के लिए, संख्याएँ जोड़ने वाला मेथड केवल संख्यात्मक प्रकार स्वीकार करे।
टाइप बाउंड उन प्रकारों को सीमित करने देते हैं जिन्हें टाइप पैरामीटर के रूप में उपयोग किया जा सकता है। ऊपरी बाउंड (<:) का अर्थ है कि टाइप पैरामीटर किसी दिए गए प्रकार का उपप्रकार होना चाहिए। उदाहरण के लिए, [T <: Animal] का अर्थ है कि T, Animal या उसका कोई उपप्रकार होना चाहिए।
class Animal { def speak(): String = "..." }
class Dog extends Animal { override def speak(): String = "Woof!" }
class Cat extends Animal { override def speak(): String = "Meow!" }
// This box can only hold types that are Animal or its subtypes
class AnimalShelter[T <: Animal](val animal: T) {
def getAnimalSound: String = animal.speak()
}
object Main {
def main(args: Array[String]): Unit = {
val dogShelter = new AnimalShelter(new Dog())
println(s"Dog says: ${dogShelter.getAnimalSound}")
val catShelter = new AnimalShelter(new Cat())
println(s"Cat says: ${catShelter.getAnimalSound}")
// This would NOT compile because Car is not an Animal:
// class Car
// val carShelter = new AnimalShelter(new Car())
}
}जेनेरिक क्लास चुनौती
जेनेरिक के बारे में अपनी समझ जाँचने का समय आ गया है!
निम्नलिखित कथनों को ध्यान से पढ़ें और स्काला में जेनेरिक क्लास और मेथड से संबंधित सभी सही कथन चुनें।
जेनेरिक: मुख्य बातें
इस पाठ में हमने स्काला के जेनेरिक के बारे में सीखा, जो लचीला और टाइप-सुरक्षित कोड लिखने की एक शक्तिशाली सुविधा है।
- जेनेरिक क्लास और मेथड को अलग-अलग प्रकारों पर काम करने देते हैं।
- इनमें वास्तविक प्रकारों के स्थान पर टाइप पैरामीटर (जैसे
[T]) का उपयोग किया जाता है। - जेनेरिक संकलन-समय टाइप सुरक्षा प्रदान करते हैं और रनटाइम त्रुटियों को रोकते हैं।
- स्काला का टाइप अनुमान अक्सर जेनेरिक कोड को संक्षिप्त बना देता है।
- टाइप बाउंड (जैसे
<:) टाइप पैरामीटर को विशिष्ट उपप्रकारों तक सीमित कर सकते हैं।
जेनेरिक का उपयोग करके आप ऐसे पुनः उपयोग योग्य घटक लिख सकते हैं जो विश्वसनीय हों और विभिन्न डेटा प्रकारों के अनुसार ढल सकें। इससे आपका स्काला कोड अधिक शक्तिशाली और त्रुटियों से कम प्रभावित होता है।
एआई शिक्षक के साथ Scala सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 39
- पाठ
- 143
अक्सर पूछे जाने वाले प्रश्न
क्या “जेनेरिक और प्रकार पैरामीटर” पाठ निःशुल्क है?
हाँ—“जेनेरिक और प्रकार पैरामीटर” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 3 पाठ शामिल हैं।
“जेनेरिक और प्रकार पैरामीटर” में मैं क्या सीखूँगा?
प्रकार-सुरक्षा के साथ पुनः उपयोग योग्य घटक बनाने के लिए जेनेरिक क्लास और विधियाँ लिखना समझें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 3 में से 1वाँ पाठ है।
“जेनेरिक और प्रकार पैरामीटर” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- जेनेरिक और प्रकार पैरामीटर
- वैरिएंस: सहवैरिएंस और प्रतिवैरिएंस
- प्रकार क्लास और इम्प्लिसिट