જેનેરિક્સ તમને અભ્યાસક્રમો, ઇન્ટરફેસ અને પદ્ધતિઓ લખવા દે છે જે પ્રકારના પરિમાણ સાથે કામ કરે છે જે કૉલર દ્વારા નિર્દિષ્ટ છે — સંકલન સમયે પ્રકારની સલામતી પ્રદાન કરે છે અને કાસ્ટિંગને દૂર કરે છે. તેઓ Collections ફ્રેમવર્ક અને પુનઃવ્યવહારી લાઇબ્રેરીઓને શક્તિ આપે છે.
();
list.add();
list.add();
(String) list.get();
List<String> list = <>();
list.add();
list.add();
list.get();
જેનેરિક્સ ચોક્કસ ભૂલોને રનટાઇમ (ClassCastException) થી સંકલન સમયે ખસેડે છે, અને ગેરહાજર કાસ્ટિંગની જરૂરિયાતને દૂર કરે છે — કોડને વધુ સુરક્ષિત અને સ્વચ્છ બનાવે છે.
// 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
વાઇલ્ડકાર્ડ્સ પદ્ધતિ પરિમાણોને લવચીકતા ઉમેરે છે જે પ્રકારોની શ્રેણીને સ્વીકાર કરવી જોઈએ.
// 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 પ્રકાર擦除 દ્વારા જેનેરિક્સ લાગુ કરે છે — પ્રકારના પરિમાણો સંકલન સમયે અસ્તિત્વમાં છે પરંતુ રનટાઇમ પર દૂર કર્યા જાય છે, જેમાં કેટલીક મર્યાદાઓ છે.
જેનેરિક્સ આધુનિક Java માટે આવશ્યક છે — તેઓ સંકલન સમયે પ્રકારની સલામતી પ્રદાન કરે છે (પ્રકારની ભૂલોને વહેલા અથવા રનટાઇમ ClassCastException તરીકે ઓળખતા), શબ્દોચ્છેદ અને ભૂલ-પ્રવણ કાસ્ટિંગને દૂર કરે છે, અને પુનઃવ્યવહારી, પ્રકાર-લવચીક કોડને સક્ષમ કરે છે.
તેઓ સમગ્ર Collections ફ્રેમવર્ક (List<String>, Map<K,V>) અને અસંખ્ય લાઇબ્રેરીઓનો ভিત્તિ છે.
જેનેરિક વર્ગો/પદ્ધતિઓ, બાધ્ય પરિમાણો, વાઇલ્ડકાર્ડ્સ (PECS) અને પ્રકાર-擦除 ચેતવણીને સમજવું તમને જેનેરિક API ને યોગ્ય રીતે ઉપયોગ કરવા અને તમારી પોતાની પુનઃવ્યવહારી, પ્રકાર-સુરક્ષિત અમૂર્તતાઓને ડિજાઇન કરવા દે છે — મજબૂત, વ્યવસ્થાપનીય Java લખવા માટે મુખ્ય કૌશલ્ય.