नमस्ते! आइए जेनरिक के अपने अध्ययन को जारी रखें। आप पिछले पाठों से उनके बारे में पर्याप्त ज्ञान प्राप्त कर चुके हैं ( जेनरिक के साथ काम करते समय varargs का उपयोग करने के बारे में और टाइप इरेज़र के बारे में ), लेकिन एक महत्वपूर्ण विषय है जिस पर हमने अभी तक विचार नहीं किया है - वाइल्डकार्ड । यह जेनरिक की बहुत महत्वपूर्ण विशेषता है। इतना अधिक कि हमने इसके लिए एक अलग पाठ समर्पित किया है! उस ने कहा, वाइल्डकार्ड के बारे में विशेष रूप से जटिल कुछ भी नहीं है। आप इसे तुरंत देखेंगे :) ![जेनरिक में वाइल्डकार्ड - 1]()
आइए एक उदाहरण देखें:
आइए एक उदाहरण देखें:
public class Main {
public static void main(String[] args) {
String str = new String("Test!");
// No problem
Object obj = str;
List<String> strings = new ArrayList<String>();
// Compilation error!
List<Object> objects = strings;
}
}
Stringवस्तु को किसी Objectवस्तु में डालते हैं। यहां कोई समस्या नहीं है — सब कुछ उम्मीद के मुताबिक काम करता है। लेकिन दूसरी स्थिति में, कंपाइलर त्रुटि उत्पन्न करता है। लेकिन हम वही कर रहे हैं, है ना? इस बार हम बस कई वस्तुओं के संग्रह का उपयोग कर रहे हैं। लेकिन त्रुटि क्यों होती है? क्या फर्क पड़ता है? क्या हम एक वस्तु को एक या 20 वस्तुओं Stringपर कास्ट कर रहे हैं? किसी वस्तु और वस्तुओं के संग्रहObject के बीच एक महत्वपूर्ण अंतर है । यदि कक्षा कक्षा की संतान है , तो कक्षा की संतान नहीं है । यही कारण है कि हम अपने को a में कास्ट नहीं कर पाएBACollection<B>Collection<A>List<String>List<Object>. Stringकी संतान है Object, लेकिन List<String>की संतान नहीं है List<Object>। यह अति सहज ज्ञान युक्त नहीं लग सकता है। भाषा के रचनाकारों ने इसे ऐसा क्यों बनाया? आइए कल्पना करें कि संकलक हमें कोई त्रुटि नहीं देता है:
List<String> strings = new ArrayList<String>();
List<Object> objects = strings;
objects.add(new Object());
String s = strings.get(0);
List<Object>संदर्भ बनाने की अनुमति दी जो इंगित करता है strings, हम संग्रह Objectमें कोई भी पुरानी वस्तु जोड़ सकते हैं strings! इस प्रकार, हमने गारंटी खो दी है कि हमारे संग्रह में केवल Stringसामान्य प्रकार के आमंत्रण में प्रकार तर्क द्वारा निर्दिष्ट वस्तुएं शामिल हैं । दूसरे शब्दों में, हमने जेनरिक-टाइप सुरक्षा का मुख्य लाभ खो दिया है। और क्योंकि कंपाइलर ने हमें ऐसा करने से नहीं रोका, हमें केवल रन टाइम पर एक त्रुटि मिलेगी, जो हमेशा एक संकलन त्रुटि से बहुत खराब होती है। इस तरह की स्थितियों को रोकने के लिए, कंपाइलर हमें एक एरर देता है:
// Compilation error
List<Object> objects = strings;
List<String>का वंशज नहीं है List<Object>। यह जेनरिक के लिए एक दृढ़ नियम है, और उनके साथ काम करते समय इसे याद रखना चाहिए। पर चलते हैं। मान लीजिए कि हमारे पास एक छोटा वर्ग पदानुक्रम है:
public class Animal {
public void feed() {
System.out.println("Animal.feed()");
}
}
public class Pet extends Animal {
public void call() {
System.out.println("Pet.call()");
}
}
public class Cat extends Pet {
public void meow() {
System.out.println("Cat.meow()");
}
}
iterateAnimals()विधि बनाने की आवश्यकता है। Animalविधि को किसी भी जानवर ( ,,,, ) का संग्रह लेना चाहिए , सभी तत्वों पर पुनरावृति करना चाहिए, और प्रत्येक पुनरावृत्ति के दौरान कंसोल पर एक संदेश प्रदर्शित करना चाहिए Pet। आइए ऐसी विधि लिखने का प्रयास करें: CatDog
public static void iterateAnimals(Collection<Animal> animals) {
for(Animal animal: animals) {
System.out.println("Another iteration in the loop!");
}
}
List<Cat>और List<Dog>! List<Pet>के वंशज नहीं हैं List<Animal>! इसका मतलब यह है कि जब हम iterateAnimals()बिल्लियों की सूची के साथ विधि को कॉल करने का प्रयास करते हैं, तो हमें एक संकलन त्रुटि मिलती है:
import java.util.*;
public class Main3 {
public static void iterateAnimals(Collection<Animal> animals) {
for(Animal animal: animals) {
System.out.println("Another iteration in the loop!");
}
}
public static void main(String[] args) {
List<Cat> cats = new ArrayList<>();
cats.add(new Cat());
cats.add(new Cat());
cats.add(new Cat());
cats.add(new Cat());
// Compilation error!
iterateAnimals(cats);
}
}
public static void iterateAnimals(Collection<? extends Animal> animals) {
for(Animal animal: animals) {
System.out.println("Another iteration in the loop!");
}
}
Animalवस्तुओं के संग्रह या किसी भी वर्ग की वस्तुओं के संग्रह को स्वीकार करती है जो Animal(? जानवरों को फैलाती है) से उतरती है। दूसरे शब्दों में, विधि Animal, Pet, Dog, या Catवस्तुओं के संग्रह को स्वीकार कर सकती है - इससे कोई फर्क नहीं पड़ता। आइए खुद को विश्वास दिलाएं कि यह काम करता है:
public static void main(String[] args) {
List<Animal> animals = new ArrayList<>();
animals.add(new Animal());
animals.add(new Animal());
List<Pet> pets = new ArrayList<>();
pets.add(new Pet());
pets.add(new Pet());
List<Cat> cats = new ArrayList<>();
cats.add(new Cat());
cats.add(new Cat());
List<Dog> dogs = new ArrayList<>();
dogs.add(new Dog());
dogs.add(new Dog());
iterateAnimals(animals);
iterateAnimals(pets);
iterateAnimals(cats);
iterateAnimals(dogs);
}
Another iteration in the loop!
Another iteration in the loop!
Another iteration in the loop!
Another iteration in the loop!
Another iteration in the loop!
Another iteration in the loop!
Another iteration in the loop!
Another iteration in the loop!
Animal, Petनीचे की कक्षा के साथ, और अगले स्तर पर Catऔर कक्षाएं। Dogअब आपको iterateAnimals()विधि को फिर से लिखने की आवश्यकता है ताकि कुत्तों को छोड़कर किसी भी प्रकार के जानवरों के साथ काम किया जा सके । यानी इसे स्वीकार करना चाहिए Collection<Animal>,Collection<Pet>या Collection<Car>, लेकिन इसके साथ काम नहीं करना चाहिए Collection<Dog>। हम इसे कैसे प्राप्त कर सकते हैं? ऐसा लगता है कि हम फिर से प्रत्येक प्रकार के लिए एक अलग विधि लिखने की संभावना का सामना करते हैं:/हम संकलक को और कैसे समझाते हैं कि हम क्या करना चाहते हैं? यह वास्तव में काफी सरल है! एक बार फिर, वाइल्डकार्ड यहां हमारी सहायता के लिए आते हैं। लेकिन इस बार हम एक अन्य प्रकार के वाइल्डकार्ड का उपयोग करेंगे - एक निचली सीमा वाला वाइल्डकार्ड , जिसे सुपर का उपयोग करके व्यक्त किया जाता है ।
public static void iterateAnimals(Collection<? super Cat> animals) {
for(int i = 0; i < animals.size(); i++) {
System.out.println("Another iteration in the loop!");
}
}
<? super Cat>संकलक को बताता है कि iterateAnimals()विधि इनपुट के रूप में वस्तुओं के संग्रह Catया Catवर्ग के किसी पूर्वज को इनपुट के रूप में स्वीकार कर सकती है। इस मामले में, Catवर्ग, उसके माता-पिता Pet, और उसके माता-पिता के माता-पिता, Animalसभी इस विवरण से मेल खाते हैं। वर्ग Dogहमारे प्रतिबंध से मेल नहीं खाता है, इसलिए तर्क के साथ विधि का उपयोग करने का प्रयास List<Dog>एक संकलन त्रुटि का परिणाम देगा:
public static void main(String[] args) {
List<Animal> animals = new ArrayList<>();
animals.add(new Animal());
animals.add(new Animal());
List<Pet> pets = new ArrayList<>();
pets.add(new Pet());
pets.add(new Pet());
List<Cat> cats = new ArrayList<>();
cats.add(new Cat());
cats.add(new Cat());
List<Dog> dogs = new ArrayList<>();
dogs.add(new Dog());
dogs.add(new Dog());
iterateAnimals(animals);
iterateAnimals(pets);
iterateAnimals(cats);
// Compilation error!
iterateAnimals(dogs);
}
GO TO FULL VERSION