హాయ్! జెనరిక్స్ గురించి మన అధ్యయనాన్ని కొనసాగిద్దాం. మీరు ఇప్పటికే మునుపటి పాఠాల నుండి వాటి గురించి గణనీయమైన జ్ఞానాన్ని పొందారు ( జనరిక్స్‌తో పనిచేసేటప్పుడు మరియు టైప్ ఎరేజర్ గురించి 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. ఇక్కడ ఎటువంటి సమస్యలు లేవు - ప్రతిదీ ఊహించిన విధంగా పని చేస్తుంది. కానీ రెండవ పరిస్థితిలో, కంపైలర్ లోపాన్ని సృష్టిస్తుంది. కానీ మేము అదే పని చేస్తున్నాము, కాదా? ఈసారి మేము అనేక వస్తువుల సేకరణను ఉపయోగిస్తున్నాము. కానీ లోపం ఎందుకు సంభవిస్తుంది? తేడా ఏమిటి? Stringమనం ఒక వస్తువును Objectలేదా 20 వస్తువులకు ప్రసారం చేస్తున్నామా ? ఒక వస్తువు మరియు వస్తువుల సేకరణ మధ్య ఒక ముఖ్యమైన వ్యత్యాసం ఉంది . తరగతి తరగతికి చెందిన పిల్లవాడు అయితే , . 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ఏదైనా పాత వస్తువును జోడించవచ్చు ! అందువల్ల, మా సేకరణలో సాధారణ రకం ఆహ్వానంలో టైప్ ఆర్గ్యుమెంట్ ద్వారా పేర్కొన్న వస్తువులు మాత్రమే ఉన్నాయని మేము హామీని కోల్పోయాము . ఇతర మాటలలో, మేము జెనరిక్స్ యొక్క ప్రధాన ప్రయోజనాన్ని కోల్పోయాము — రకం భద్రత. మరియు కంపైలర్ దీన్ని చేయకుండా మమ్మల్ని ఆపలేదు కాబట్టి, రన్ టైమ్‌లో మాత్రమే మనకు ఎర్రర్ వస్తుంది, ఇది ఎల్లప్పుడూ కంపైలేషన్ ఎర్రర్ కంటే చాలా ఘోరంగా ఉంటుంది. ఇలాంటి పరిస్థితులను నివారించడానికి, కంపైలర్ మాకు లోపాన్ని ఇస్తుంది: ObjectstringsString
// 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, Cat, Dog), అన్ని మూలకాలపై మళ్ళించాలి మరియు ప్రతి పునరావృత సమయంలో కన్సోల్‌లో సందేశాన్ని ప్రదర్శించాలి. అటువంటి పద్ధతిని వ్రాయడానికి ప్రయత్నిద్దాం:
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సేకరణను అంగీకరించగలదు - దీనికి ఎటువంటి తేడా లేదు. ఇది పని చేస్తుందని మనల్ని మనం ఒప్పించుకుందాం: AnimalPetDogCat
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()CatCatCatPetAnimalDogList<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