జెనరిక్స్: క్లాస్

"హాయ్! నేను జెనరిక్స్‌పై ఎల్లీ పాఠాన్ని కొనసాగించబోతున్నాను. వినడానికి సిద్ధంగా ఉన్నారా?"

"అవును."

"అప్పుడు ప్రారంభిద్దాం."

"మీరు తెలుసుకోవలసిన మొదటి విషయం ఏమిటంటే, తరగతి యొక్క పద్ధతులు వాటి స్వంత రకం పారామితులను కూడా కలిగి ఉంటాయి."

"నాకు తెలుసు."

"లేదు, నేను ప్రత్యేకంగా వారి స్వంత రకం పారామితులను ఉద్దేశించాను: "

class Calculator
{
  T add(T a, T b); // Add
  T sub(T a, T b); // Subtract
  T mul(T a, T b); // Multiply
  T div(T a, T b); // Divide
}

"ఈ రకం పారామితులు ప్రత్యేకంగా పద్ధతులకు సంబంధించినవి. తరగతికి పారామీటర్‌లు లేవు. మీరు ఈ పద్ధతులను స్టాటిక్‌గా ప్రకటించవచ్చు మరియు ఆబ్జెక్ట్ లేకుండా వాటిని కాల్ చేయవచ్చు."

"నేను చూస్తున్నాను. మెథడ్స్‌లో టైప్ పారామీటర్‌ల పాయింట్ క్లాస్‌ల మాదిరిగానే ఉందా?"

"అవును. అయితే కొత్తదనం ఉంది."

"మీకు ఇప్పటికే తెలిసినట్లుగా, మీరు టైప్ డిక్లరేషన్‌లో వైల్డ్‌కార్డ్‌ని ఉపయోగించవచ్చు. తర్వాత కింది పరిస్థితిని ఊహించండి:"

public void doSomething(List<? extends MyClass> list)
{
 for(MyClass object : list)
 {
  System.out.println(object.getState()); // Everything works well here.
 }
}

"అయితే మనం సేకరణకు కొత్త అంశాన్ని జోడించాలనుకుంటే ఏమి చేయాలి:"

public void doSomething(List<? extends MyClass> list)
{
 list.add(new MyClass()); // Error!
}

"సమస్య ఏమిటంటే, సాధారణ సందర్భంలో doSomething పద్ధతి ఒక జాబితాను ఆమోదించవచ్చు, దీని మూలకాలు MyClass ఆబ్జెక్ట్‌లు కావు, కానీ MyClass యొక్క ఏదైనా సబ్‌క్లాస్‌లోని వస్తువులు. కానీ మీరు అటువంటి జాబితాకు MyClass ఆబ్జెక్ట్‌లను జోడించలేరు!"

"అయ్యో. కాబట్టి, దాని గురించి ఏమి చేయవచ్చు?"

"ఏమీ లేదు. ఈ పరిస్థితిలో, మీరు ఏమీ చేయలేరు. కానీ ఇది జావా క్రియేటర్‌లకు కొంత ఆలోచించేలా చేసింది. మరియు వారు కొత్త కీవర్డ్‌తో ముందుకు వచ్చారు: సూపర్ ."

"సింటాక్స్ దాదాపు ఒకే విధంగా ఉంది:"

List<? super MyClass> list

కానీ పొడిగింపులు మరియు సూపర్ మధ్య ఒక ముఖ్యమైన వ్యత్యాసం ఉంది.

"«? T విస్తరిస్తుంది» అంటే తరగతి తప్పనిసరిగా T యొక్క వారసుడు అయి ఉండాలి."

"«? సూపర్ T» అంటే తరగతి తప్పనిసరిగా T యొక్క పూర్వీకులు అయి ఉండాలి."

"పవిత్ర మోలీ. అయితే ఇది ఎక్కడ ఉపయోగించబడుతుంది?"

"«? సూపర్ T» అనేది T ఆబ్జెక్ట్‌ల సేకరణకు జోడించే పద్ధతిని కలిగి ఉన్నప్పుడు ఉపయోగించబడుతుంది. ఈ సందర్భంలో, ఇది T ఆబ్జెక్ట్‌ల సేకరణ లేదా T యొక్క ఏదైనా పూర్వీకులు కావచ్చు."

"ఆహ్. AT ఆబ్జెక్ట్‌ని T యొక్క పూర్వీకుల రకంగా ఉండే సూచన వేరియబుల్‌కు కేటాయించవచ్చు"

"నిజాయితీగా చెప్పాలంటే, ఈ విధానం చాలా తరచుగా ఉపయోగించబడదు. అంతేకాదు, దీనికి ఒక లోపం ఉంది. ఉదాహరణకు:"

public void doSomething(List<? super MyClass> list)
{
 for(MyClass object : list) // Error!
 {
  System.out.println(object.getState());
 }
}

public void doSomething(List<? super MyClass> list)
{
 list.add(new MyClass()); // Everything works well here.
}

"ఇప్పుడు మొదటి ఉదాహరణ పనిచేయదు."

"జాబితా ఒక జాబితా<ఆబ్జెక్ట్> కూడా కావచ్చు (ఆబ్జెక్ట్ అనేది MyClass యొక్క టాప్ సూపర్ క్లాస్), మేము తప్పనిసరిగా కింది చెల్లని కోడ్‌ని వ్రాస్తున్నాము:"

List<Object> list;

for(MyClass object : list) // Error!
{
 System.out.println(object.getState());
}

"నేను చూస్తున్నాను. ఆసక్తికరమైన పాఠానికి ధన్యవాదాలు."

"మీకు స్వాగతం."