பொதுவானவை

"வணக்கம், அமிகோ!"

"ஹாய், எல்லி!"

"இன்னைக்கு நானும் ரிஷியும் உங்களுக்கு ஜெனரிக்ஸ் பற்றி எல்லாம் சொல்லப் போறோம்."

"காத்திருங்கள், நான் ஏற்கனவே எல்லாவற்றையும் அறிந்திருக்கிறேன் என்று நினைக்கிறேன்."

"கிட்டத்தட்ட எல்லாம், ஆனால் எல்லாம் இல்லை."

"அப்படியா? சரி, நான் கேட்கத் தயார்."

"அப்படியானால் ஆரம்பிக்கலாம்."

"ஜாவாவில், ஜெனரிக்ஸ் என்பது வகை அளவுருக்கள் கொண்ட வகுப்புகள்."

"ஜெனரிக்ஸ் ஏன் கண்டுபிடிக்கப்பட்டது என்பதற்கு, குறியீட்டில் உள்ள கருத்துகளைப் பார்க்கவும்:"

ArrayList stringList = new ArrayList();
stringList.add("abc"); // Add a string to the list
stringList.add("abc"); // Add a string to the list
stringList.add( 1 ); // Add a number to the list

for(Object o: stringList)
{
 String s = (String) o; // There will be an exception here when we get to the integer
}

ஜெனரிக்ஸைப் பயன்படுத்தி சிக்கலை எவ்வாறு தீர்ப்பது:

ArrayList<String> stringList = new ArrayList<String>();
stringList.add("abc"); // Add a string to the list
stringList.add("abc"); // Add a string to the list
stringList.add( 1 ); // There will be a compilation error here

for(Object o: stringList)
{
 String s = (String) o;
}

"இந்தக் குறியீடு தொகுக்கப்படாது, மேலும் தவறான தரவு வகையைச் சேர்ப்பதால் ஏற்படும் பிழை தொகுக்கும்போது கவனிக்கப்படும்."

"ஆம், இது எனக்கு முன்பே தெரியும்."

"சரி, நல்லது. திரும்பத் திரும்பச் சொல்வது கற்றலின் தாய்."

"ஆனால் ஜாவாவின் படைப்பாளிகள் ஜெனரிக்ஸை உருவாக்கும் போது கொஞ்சம் சோம்பேறியாக இருந்தார்கள். முழு அளவிலான வகைகளை அளவுருக்கள் மூலம் உருவாக்குவதற்குப் பதிலாக, அவர்கள் மென்மையாய் மேம்படுத்துவதில் நழுவினார்கள். உண்மையில், அவர்கள் வகை அளவுருக்கள் பற்றிய எந்த தகவலையும் ஜெனரிக்ஸில் சேர்க்கவில்லை. மாறாக, அனைத்து தொகுப்பின் போது மந்திரம் நிகழ்கிறது."

List<String> strings = new ArrayList<String>();
strings.add("abc");
strings.add("abc");
strings.add( 1); // Compilation error

for(String s: strings)
{
 System.out.println(s);
}

List strings = new ArrayList();

strings.add((String)"abc");
strings.add((String)"abc");
strings.add((String) 1); // Compilation error

for(String s: strings)
{
 System.out.println(s);
}

"அது மென்மையாய் இருக்கிறது."

"ஆம், ஆனால் இந்த அணுகுமுறை ஒரு பக்க விளைவைக் கொண்டுள்ளது.  வகை அளவுருக்கள் பற்றிய எந்த தகவலும் ஒரு பொதுவான வகுப்பில் சேமிக்கப்படவில்லை. இந்த அணுகுமுறை பின்னர் வகை அழிப்பு  என அறியப்பட்டது ."

"வேறு வார்த்தைகளில் கூறுவதானால், வகை அளவுருக்கள் கொண்ட உங்கள் சொந்த வகுப்பை நீங்கள் வைத்திருந்தால், அவற்றைப் பற்றிய தகவலை வகுப்பிற்குள் பயன்படுத்த முடியாது."

class Zoo<T>
{
 ArrayList<T> pets = new ArrayList<T>();

 public T createAnimal()
 {
  T animal = new T();
  pets.add(animal)
  return animal;
 }
}

class Zoo
{
 ArrayList pets = new ArrayList();

 public Object createAnimal()
 {
  Object animal = new ???();
  pets.add(animal)
  return animal;
 }
}

"தொகுக்கும்போது, ​​அனைத்து அளவுரு வகைகளும் பொருளால் மாற்றப்படுகின்றன. மேலும் வகுப்பிற்குள் அதற்கு அனுப்பப்பட்ட வகை பற்றிய தகவல் இல்லை."

"ஆம், நான் ஒப்புக்கொள்கிறேன், அது சிறந்ததல்ல."

"அவ்வளவு பயமில்லை. இந்தப் பிரச்சனையை எப்படிச் சமாளிப்பது என்று பிறகு சொல்கிறேன்."

ஆனால் இன்னும் இருக்கிறது. வகை அளவுருக்களுக்கான பெற்றோர் வகையைக் குறிப்பிட ஜாவா உங்களை அனுமதிக்கிறது. இதற்கு நீட்டிப்புச் சொல் பயன்படுத்தப்படுகிறது. உதாரணத்திற்கு:

class Zoo<T extends Cat>
{
 T cat;

 T getCat()
 {
  return cat;
 }

 void setCat (T cat)
 {
  this.cat = cat;
 }

 String getCatName()
 {
  return this.cat.getName();
 }
}

class Zoo
{
 Cat cat;

 Cat getCat()
 {
  return cat;
 }

 void setCat(Cat cat)
 {
  this.cat = cat;
 }

 String getCatName()
 {
  return this.cat.getName();
 }
}

"இரண்டு உண்மைகளைக் கவனியுங்கள்:"

"முதலில், நீங்கள் எந்த வகையையும் அளவுருவாக அனுப்ப முடியாது - நீங்கள் ஒரு பூனை அல்லது பூனையை மரபுரிமையாகக் கொண்ட வகுப்பில் மட்டுமே தேர்ச்சி பெற முடியும்."

"இரண்டாவதாக, மிருகக்காட்சிசாலை வகுப்பிற்குள், T வகை மாறிகள் இப்போது பூனை வகுப்பின் முறைகளை அழைக்கலாம்.  வலதுபுறத்தில் உள்ள நெடுவரிசை ஏன் விளக்குகிறது (ஏனென்றால் T உள்ளது எல்லா இடங்களிலும் Cat மாற்றப்படும்)"

ஆம்

"சரி, அது புத்திசாலி."