Generics என்றால் என்ன மற்றும் ஏன் அவற்றைப் பயன்படுத்த வேண்டும்?

Question

Accepted Answer

**Generics** வகுப்புகள், இடைமுகங்கள் மற்றும் முறைகளை எழுத உங்களை அனுமதிக்கின்றன, அவை அழைப்பவரால் நির்ணயிக்கப்படும் **வகை அளவுருவுடன்** செயல்படுகின்றன — **compile-time வகை பாதுகாப்பு** வழங்கி மற்றும் வெளிப்பாட்டுக்கான প்রয়োজனை நீக்குவது. அவை Collections Framework மற்றும் மறுபயன்படுத்தக்கூடிய நூலகங்களை சக்திசாலி செய்கின்றன. ## Generics தீர்க்கும் சிக்கல் ```java // ❌ before generics (or with raw types) — no type safety, requires casts List list = new ArrayList(); list.add("hello"); list.add(42); // oops — anything can go in String s = (String) list.get(1); // ClassCastException at RUNTIME! 💥 // ✅ with generics — the type is enforced at COMPILE time List list = new ArrayList<>(); list.add("hello"); list.add(42); // ❌ compile error — caught immediately String s = list.get(0); // no cast needed — known to be String ``` Generics வகை பிழைகளை சமயத்தில் (`ClassCastException`) **compile-time** இல் நகர்த்துகிறது, மற்றும் கையேடு வெளிப்பாட்டுக்கான தேவையை நீக்குகிறது — குறியீடை பாதுகாப்பாகவும் சுத்தமாகவும் செய்கிறது. ## Generics வகுப்புகள் மற்றும் முறைகள் ```java // a generic class — T is a type parameter filled in by the user public class Box { private T value; public void set(T value) { this.value = value; } public T get() { return value; } } Box b = new Box<>(); // T = String b.set("hi"); String x = b.get(); // typed, no cast // a generic method public static T firstElement(List list) { return list.get(0); } ``` ## எல்லைக்குட்பட்ட வகை அளவுருக்கள் ```java // T must be Number (or a subclass) — lets you call Number methods public static double sum(List list) { double total = 0; for (T n : list) total += n.doubleValue(); // safe — T is a Number return total; } ``` `` வகை அளவுருவை கட்டுப்படுத்துகிறது, அந்த வகையின் உறுப்பினர்களை பாதுகாப்பாகப் பயன்படுத்த உங்களை இயக்குகிறது. ## வெட்டுக்குறிகள் ```java List nums; // "some subtype of Number" — read (producer) List sink; // "Integer or a supertype" — write (consumer) // PECS: Producer Extends, Consumer Super ``` வெட்டுக்குறிகள் முறை அளவுருக்களுக்கு நমனீয়தை சேர்க்கின்றன, அவை வகைகளின் வரம்புகளை ஏற்றுக்கொள்ள வேண்டும். ## வகை erasure (Java எச்சரிக்கை) ```java // generics are a COMPILE-TIME feature — erased at runtime (for backward compatibility) List a = new ArrayList<>(); List b = new ArrayList<>(); a.getClass() == b.getClass(); // true — both are just ArrayList at runtime // consequence: can't do `new T()` or `instanceof List` ``` Java generics ஐ **வகை erasure** மூலம் செயல்படுத்துகிறது — வகை அளவுருக்கள் compile-time இல் இருக்கின்றன ஆனால் மேலோட்ட நேரத்தில் அகற்றப்படுகின்றன, இதில் சில வரம்புகள் உள்ளன. ## ஏன் இது முக்கியம் Generics நவீன Java க்கு அপরிহார்யமானவை — அவை compile-time வகை பாதுகாப்பு (வகை பிழைகளை ஆரம்ப நேரத்தில் சமயத்தின் `ClassCastException` என பதிவு செய்கிறது), விரிவான மற்றும் பிழை-மனப்போக்கு வெளிப்பாடுகளை நீக்குகின்றன, மற்றும் மறுபயன்படுத்தக்கூடிய, வகை-நমனீய குறியீட்டை இயக்குகின்றன. அவை முழு Collections Framework (`List`, `Map`) மற்றும் எண்ணற்ற நூலகங்களின் அடிப்படையாகும். Generics வகுப்புகள்/முறைகள், எல்லைக்குட்பட்ட அளவுருக்கள், வெட்டுக்குறிகள் (PECS), மற்றும் வகை-erasure எச்சரிக்கையைப் புரிந்துகொள்வது உங்களை generic API களை சரியாக பயன்படுத்தவும் உங்களின் சொந்த மறுபயன்படுத்தக்கூடிய, வகை-பாதுகாப்பான abstractions ஐ வடிவமைக்கவும் இயக்குகிறது — வலிமையான, பராமரிக்கக்கூடிய Java எழுத ஒரு முக்கிய திறமை.