जेनेरिक्स ले तपाइँलाई क्लास, इन्टरफेस र मेथड लेख्न दिन्छ जुन टाइप प्यारामिटर द्वारा निर्दिष्ट गरिएको कलर द्वारा काम गर्छ — compile-time टाइप सेफ्टी प्रदान गरेर र casts लाई हटाएर। तिनले Collections Framework र पुन: प्रयोगयोग्य लाइब्रेरीहरूलाई शक्तिशाली बनाउन्छन्।
();
list.add();
list.add();
(String) list.get();
List<String> list = <>();
list.add();
list.add();
list.get();
जेनेरिक्सले टाइप त्रुटिहरूलाई runtime (ClassCastException) बाट compile time मा सारिदिन्छ, र manual casts को आवश्यकता हटाइदिन्छ — कोडलाई सुरक्षित र सफा बनाएर।
// a generic class — T is a type parameter filled in by the user
public class Box<T> {
private T value;
public void set(T value) { this.value = value; }
public T get() { return value; }
}
Box<String> b = new Box<>(); // T = String
b.set("hi");
String x = b.get(); // typed, no cast
// a generic method
public static <T> T firstElement(List<T> list) {
return list.get(0);
}
// T must be Number (or a subclass) — lets you call Number methods
public static <T extends Number> double sum(List<T> list) {
double total = 0;
for (T n : list) total += n.doubleValue(); // safe — T is a Number
return total;
}
<T extends X> ले टाइप प्यारामिटरलाई सीमाबद्ध गर्छ, यसले तपाइँलाई त्यो टाइपका सदस्यहरू सुरक्षित रूपमा प्रयोग गर्न सक्षम बनाउँछ।
List<? extends Number> nums; // "some subtype of Number" — read (producer)
List<? super Integer> sink; // "Integer or a supertype" — write (consumer)
// PECS: Producer Extends, Consumer Super
Wildcards ले मेथड प्यारामिटरहरूको लागि flexibility थप्छ जसले टाइपहरूको दायरा स्वीकार गर्नुपर्छ।
// generics are a COMPILE-TIME feature — erased at runtime (for backward compatibility)
List<String> a = new ArrayList<>();
List<Integer> b = new ArrayList<>();
a.getClass() == b.getClass(); // true — both are just ArrayList at runtime
// consequence: can't do `new T()` or `instanceof List<String>`
Java ले जेनेरिक्सलाई type erasure मार्फत लागू गर्छ — टाइप प्यारामिटरहरू compile time मा अवस्थित हुन्छन् तर runtime मा हटाइएको हुन्छ, जसको केही सीमाहरू छन्।
जेनेरिक्स आधुनिक Java को लागि आवश्यक छन् — तिनले compile-time टाइप सेफ्टी प्रदान गर्छन् (टाइप त्रुटिहरूलाई शीघ्र पक्राउ गरेर runtime ClassCastExceptions को सट्टा), verbose र त्रुटि-प्रवण casts लाई हटाउँछन्, र पुन: प्रयोगयोग्य, टाइप-लचकदार कोडलाई सक्षम बनाउँछन्।
तिनले सम्पूर्ण Collections Framework (List<String>, Map<K,V>) र अनगिनत लाइब्रेरीहरूको आधार हुन्।
जेनेरिक क्लास/मेथड, बाउन्डेड प्यारामिटर, wildcards (PECS), र type-erasure सावधानीलाई बुझ्नु भनेको जेनेरिक APIs लाई सही तरीकले प्रयोग गर्न र आफ्नो स्वयंको पुन: प्रयोगयोग्य, टाइप-सेफ अब्सट्रेक्सन डिजाइन गर्न सक्षम हुनु हो — मजबूत, रखरखाव गर्न सकिने Java लेख्नको लागि एक मूल कौशल।