जावा में जेनेरिक

जेनरिक सामान्य प्रोग्रामिंग की सुविधा है, जिसे 2004 में जावा प्लेटफ़ॉर्म, मानक संस्करण 5.0 के अन्दर जावा (प्रोग्रामिंग भाषा) में जोड़ा गया था। उन्हें संकलन-समय प्रकार की सुरक्षा प्रदान करते हुए विभिन्न प्रकार की वस्तुओं पर एक प्रकार या विधि को संचालित करने की अनुमति देने के लिए जावा के प्रकार प्रणाली का विस्तार करने के लिए डिज़ाइन किया गया था। पहलू संकलन-समय प्रकार की सुरक्षा पूरी तरह से प्राप्त नहीं की गई थी, क्योंकि 2016 में यह दिखाया गया था कि सभी स्थितियों में इसकी गारंटी नहीं है।

जावा संग्रह ढाँचा संग्रह उदाहरण में संग्रहीत वस्तुओं के प्रकार को निर्दिष्ट करने के लिए जेनेरिक का समर्थन करता है।

1998 में, गिलाद ब्राचा, मार्टिन ओडर्सकी , डेविड स्टाउटमायर और फिलिप वाडलर ने जेनेरिक जावा बनाया, जो सामान्य प्रकारों का समर्थन करने के लिए जावा भाषा का विस्तार था। जेनेरिक जावा को वाइल्डकार्ड (जावा) के साथ जावा में सम्मिलित किया गया था।

पदानुक्रम और वर्गीकरण

जावा भाषा विशिष्टता के अनुसार:

• एक प्रकार का चर अयोग्य पहचानकर्ता है। प्रकार चर को जेनेरिक क्लास डिक्लेरेशन, जेनेरिक इंटरफ़ेस डिक्लेरेशन, जेनेरिक मेथड डिक्लेरेशन और जेनेरिक कंस्ट्रक्टर डिक्लेरेशन द्वारा प्रस्तुत किया जाता है।
• वर्ग सामान्य है, यदि वह एक या अधिक प्रकार के चर घोषित करता है। यह एक या अधिक प्रकार के वेरिएबल को परिभाषित करता है, जो पैरामीटर के रूप में कार्य करते हैं। सामान्य वर्ग घोषणा पैरामीटरयुक्त प्रकारों के सेट को परिभाषित करती है, जो प्रकार पैरामीटर अनुभाग के प्रत्येक संभावित आह्वान के लिए एक है। ये सभी पैरामीटरयुक्त प्रकार रनटाइम पर एक ही क्लास साझा करते हैं।
• इंटरफ़ेस (जावा) सामान्य है यदि यह एक या अधिक प्रकार के चर घोषित करता है। यह एक या अधिक प्रकार के वेरिएबल को परिभाषित करता है, जो पैरामीटर के रूप में कार्य करते हैं। सामान्य इंटरफ़ेस घोषणा प्रकार के सेट को परिभाषित करती है, प्रकार पैरामीटर अनुभाग के प्रत्येक संभावित आह्वान के लिए एक। सभी पैरामीटरयुक्त प्रकार रनटाइम पर समान इंटरफ़ेस साझा करते हैं।
• विधि सामान्य है यदि यह एक या अधिक प्रकार के चर घोषित करती है। इस प्रकार के चर को विधि के औपचारिक प्रकार के पैरामीटर के रूप में जाना जाता है। औपचारिक प्रकार पैरामीटर लिस्ट का रूप किसी वर्ग या इंटरफ़ेस के प्रकार पैरामीटर लिस्ट के समान है।
• कंस्ट्रक्टर को जेनेरिक घोषित किया जा सकता है, चाहे कंस्ट्रक्टर को जिस वर्ग में घोषित किया गया है वह स्वयं जेनेरिक है या नहीं। कंस्ट्रक्टर सामान्य होता है यदि वह एक या अधिक प्रकार के वेरिएबल घोषित करता है। इन प्रकार के चर को कंस्ट्रक्टर के औपचारिक प्रकार के पैरामीटर के रूप में जाना जाता है। औपचारिक प्रकार पैरामीटर लिस्ट का रूप सामान्य वर्ग या इंटरफ़ेस की प्रकार पैरामीटर लिस्ट के समान है।

प्रेरणा

जावा कोड का निम्नलिखित ब्लॉक उस समस्या को दर्शाता है, जो जेनेरिक का उपयोग न करने पर उपलब्ध होती है। सबसे पहले, यह Object प्रकार की ArrayList घोषित करता है। फिर, यह ArrayList में String जोड़ता है। अंत में, यह जोड़े गए String को पुनः प्राप्त करने का प्रयास करता है और इसे Integer में डालने का प्रयास करता है - लॉजिक में त्रुटि, क्योंकि सामान्यतः पूर्णांक में इच्छानुसार स्ट्रिंग डालना संभव नहीं है।

final List v = new ArrayList();
v.add("test"); // A String that cannot be cast to an Integer
final Integer i = (Integer) v.get(0); // Run time error

चूँकि कोड बिना किसी त्रुटि के संकलित किया गया है, यह कोड की तीसरी लाइन निष्पादित करते समय रनटाइम अपवाद (java.lang.ClassCastException) फेंकता है। जेनरिक का उपयोग करके संकलन समय के समय इस प्रकार की लॉजिक त्रुटि का पता लगाया जा सकता है और उनका उपयोग करने के लिए प्राथमिक प्रेरणा है। यह एक या अधिक प्रकार के वेरिएबल को परिभाषित करता है, जो पैरामीटर के रूप में कार्य करते हैं।

उपरोक्त कोड खंड को जेनेरिक का उपयोग करके निम्नानुसार फिर से लिखा जा सकता है:

final List<String> v = new ArrayList<String>();
v.add("test");
final Integer i = (Integer) v.get(0); // (type error)  compilation-time error

कोण कोष्ठक के अन्दर टाइप पैरामीटर String ArrayList को String (ArrayList के सामान्य Object घटकों का वंशज) से गठित होने की घोषणा करता है। जेनेरिक के साथ, तीसरी लाइन को किसी विशेष प्रकार में डालना अब आवश्यक नहीं है, क्योंकि v.get(0) के परिणाम को कंपाइलर द्वारा उत्पन्न कोड द्वारा String के रूप में परिभाषित किया गया है।

इस खंड की तीसरी लाइन में तार्किक दोष को संकलन-समय त्रुटि (J2SE 5.0 या बाद के संस्करण के साथ) के रूप में पहचाना जाएगा क्योंकि कंपाइलर यह पता लगाएगा कि v.get(0) Integer पूर्णांक के अतिरिक्त String लौटाता है। अधिक विस्तृत उदाहरण के लिए, संदर्भ देखें।

यहां पैकेज java.util में इंटरफेस java.util.List और java.util.Iterator की परिभाषा से छोटा सा अंश दिया गया है:

interface List<E> { 

    void add(E x);
    Iterator<E> iterator();

}

interface Iterator<E> {

    E next();
    boolean hasNext();

}

सामान्य वर्ग परिभाषाएँ

यहां सामान्य जावा क्लास का उदाहरण दिया गया है, जिसका उपयोग मानचित्र (कंप्यूटर विज्ञान) में व्यक्तिगत प्रविष्टियों (वैल्यू मैपिंग की कुंजी) को दर्शाने के लिए किया जा सकता है:

public class Entry<KeyType, ValueType> {
  
    private final KeyType key;
    private final ValueType value;

    public Entry(KeyType key, ValueType value) {  
        this.key = key;
        this.value = value;
    }

    public KeyType getKey() {
        return key;
    }

    public ValueType getValue() {
        return value;
    }

    public String toString() { 
        return "(" + key + ", " + value + ")";  
    }

}

इस सामान्य वर्ग का उपयोग निम्नलिखित विधियों से किया जा सकता है, उदाहरण के लिए:

final Entry<String, String> grade = new Entry<String, String>("Mike", "A");
final Entry<String, Integer> mark = new Entry<String, Integer>("Mike", 100);
System.out.println("grade: " + grade);
System.out.println("mark: " + mark);

final Entry<Integer, Boolean> prime = new Entry<Integer, Boolean>(13, true);
if (prime.getValue()) {
    System.out.println(prime.getKey() + " is prime.");
}
else {
    System.out.println(prime.getKey() + " is not prime.");
}

यह आउटपुट देता है:

grade: (Mike, A)
mark: (Mike, 100)
13 is prime.

सामान्य विधि परिभाषाएँ

उपरोक्त सामान्य वर्ग का उपयोग करते हुए सामान्य विधि का उदाहरण यहां दिया गया है:

public static <Type> Entry<Type, Type> twice(Type value) {
    return new Entry<Type, Type>(value, value);
}

नोट: यदि हम पहले <Type> को हटा दें, उपरोक्त विधि में, हमें संकलन त्रुटि मिलेगी (प्रतीक प्रकार नहीं मिल सका), क्योंकि यह प्रतीक की घोषणा का प्रतिनिधित्व करता है।

कई स्थितियों में, विधि के उपयोगकर्ता को प्रकार के पैरामीटर को इंगित करने की आवश्यकता नहीं होती है, क्योंकि उनका अनुमान लगाया जा सकता है:

final Entry<String, String> pair = Entry.twice("Hello");

यदि आवश्यक हो तो पैरामीटर स्पष्ट रूप से जोड़े जा सकते हैं:

final Entry<String, String> pair = Entry.<String>twice("Hello");

आदिम प्रकार के उपयोग की अनुमति नहीं है, और इसके अतिरिक्त ऑब्जेक्ट प्रकार (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग) बॉक्सिंग संस्करणों का उपयोग किया जाना चाहिए:

final Entry<int, int> pair; // Fails compilation. Use Integer instead.

दिए गए पैरामीटर के आधार पर सामान्य विधि बनाने की भी संभावना है।

public <Type> Type[] toArray(Type... elements) {
    return elements;
}

ऐसी स्थितियों में आप आदिम प्रकारों का भी उपयोग नहीं कर सकते, उदाहरण के लिए:

Integer[] array = toArray(1, 2, 3, 4, 5, 6);

डायमंड ऑपरेटर

प्रकार के अनुमान के लिए धन्यवाद, जावा एसई 7 और इसके बाद के संस्करण प्रोग्रामर को कोण कोष्ठक की खाली जोड़ी (<>, जिसे डायमंड ऑपरेटर कहा जाता है) को कोण कोष्ठक की जोड़ी के लिए प्रतिस्थापित करने की अनुमति देता है जिसमें एक या अधिक प्रकार के पैरामीटर होते हैं जो पर्याप्त रूप से बंद संदर्भ का तात्पर्य है। इस प्रकार, Entry का उपयोग करके उपरोक्त कोड उदाहरण को इस प्रकार पुनः लिखा जा सकता है:

final Entry<String, String> grade = new Entry<>("Mike", "A");
final Entry<String, Integer> mark = new Entry<>("Mike", 100);
System.out.println("grade: " + grade);
System.out.println("mark: " + mark);

final Entry<Integer, Boolean> prime = new Entry<>(13, true);
if (prime.getValue()) System.out.println(prime.getKey() + " is prime.");
else System.out.println(prime.getKey() + " is not prime.");

वाइल्डकार्ड टाइप करें

Main article: वाइल्डकार्ड (जावा)

पैरामीटरयुक्त प्रकार के लिए एक प्रकार का लॉजिक किसी ठोस वर्ग या इंटरफ़ेस तक सीमित नहीं है। जावा पैरामीटरयुक्त प्रकारों के लिए प्रकार के लॉजिक के रूप में "टाइप वाइल्डकार्ड" के उपयोग की अनुमति देता है। वाइल्डकार्ड "<?>" रूप में प्रकार के लॉजिक हैं; वैकल्पिक रूप से ऊपरी या निचली सीमा के साथ। यह देखते हुए कि वाइल्डकार्ड द्वारा दर्शाया गया स्पष्ट प्रकार अज्ञात है, उन विधियों के प्रकार पर प्रतिबंध लगाए जाते हैं जिन्हें किसी ऑब्जेक्ट पर बुलाया जा सकता है जो पैरामीटरयुक्त प्रकारों का उपयोग करता है।

यहां उदाहरण दिया गया है, जहां Collection<E> के तत्व प्रकार को वाइल्डकार्ड द्वारा पैरामीटराइज़ किया गया है:

final Collection<?> c = new ArrayList<String>();
c.add(new Object()); // compile-time error
c.add(null); // allowed

चूँकि हम नहीं जानते कि तत्व प्रकार c का क्या अर्थ है, हम इसमें ऑब्जेक्ट नहीं जोड़ सकते। add() विधि E e> प्रकार के लॉजिक लेती है, जो कि Collection<E> जेनेरिक इंटरफ़ेस का तत्व प्रकार है। जब वास्तविक प्रकार का लॉजिक ? होता है, तो यह किसी अज्ञात प्रकार का प्रतिनिधित्व करता है। add() विधि में हम जो भी विधि लॉजिक मान पास करते हैं वह इस अज्ञात प्रकार का उपप्रकार होना चाहिए। चूँकि हम नहीं जानते कि वह किस प्रकार का है, हम कुछ भी पारित नहीं कर सकते हैं। एकमात्र अपवाद शून्य है; जो हर प्रकार का सदस्य है।

किसी प्रकार के वाइल्डकार्ड की ऊपरी सीमा को निर्दिष्ट करने के लिए, extends कीवर्ड का उपयोग यह इंगित करने के लिए किया जाता है कि प्रकार लॉजिक बाउंडिंग क्लास का उपप्रकार है। तो List<? extends Number> का अर्थ है कि दी गई लिस्ट में कुछ अज्ञात प्रकार की वस्तुएं हैं जो Number वर्ग का विस्तार करती हैं। उदाहरण के लिए, लिस्ट List<Float> या List<Number> हो सकती है। लिस्ट से किसी तत्व को पढ़ने पर Number वापस आ जाएगी। फिर से, अशक्त तत्वों को जोड़ने की भी अनुमति है।

उपरोक्त वाइल्डकार्ड का उपयोग लचीलापन जोड़ता है क्योंकि ठोस प्रकार के लॉजिक के साथ किन्हीं दो पैरामीटरयुक्त प्रकारों के बीच कोई विरासत संबंध नहीं है। न तो List<Number> और न ही List<Integer> दूसरे का उपप्रकार है; तथापि Integer Number का उपप्रकार है। इसलिए, कोई भी विधि जो List<Number> को पैरामीटर के रूप में लेती है, List<Integer> के लॉजिक को स्वीकार नहीं करती है। यदि ऐसा होता, तो इसमें ऐसा Number सम्मिलित करना संभव होता जो Integer नहीं है; जो प्रकार की सुरक्षा का उल्लंघन करता है। यहां उदाहरण दिया गया है जो दर्शाता है कि यदि List<Integer> List<Number> का उपप्रकार होता तो किस प्रकार प्रकार की सुरक्षा का उल्लंघन किया जाता:

final List<Integer> ints = new ArrayList<>();
ints.add(2);
final List<Number> nums = ints;  // valid if List<Integer> were a subtype of List<Number> according to substitution rule. 
nums.add(3.14);  
final Integer x = ints.get(1); // now 3.14 is assigned to an Integer variable!

वाइल्डकार्ड के साथ समाधान काम करता है क्योंकि यह उन परिचालनों की अनुमति नहीं देता है जो प्रकार की सुरक्षा का उल्लंघन करेंगे:

final List<? extends Number> nums = ints;  // OK
nums.add(3.14); // compile-time error
nums.add(null); // allowed

किसी प्रकार के वाइल्डकार्ड के निचले बाउंडिंग वर्ग को निर्दिष्ट करने के लिए, super कीवर्ड का प्रयोग किया जाता है। यह कीवर्ड इंगित करता है कि प्रकार लॉजिक बाउंडिंग क्लास का सुपरटाइप है। इसलिए, List<Number> या List<Object> List<? super Number> का प्रतिनिधित्व कर सकता है। List<? के रूप में परिभाषित लिस्ट से पढ़ना super Number> Object प्रकार के तत्व लौटाता है। ऐसी लिस्ट में जोड़ने के लिए या तो Number प्रकार के तत्वों, Number के किसी उपप्रकार या शून्य (जो हर प्रकार का सदस्य है) की आवश्यकता होती है।

जोशुआ बलोच की पुस्तक इफेक्टिव जावा से स्मरणीय पीईसीएस (निर्माता एक्सटेंड्स, कंज्यूमर सुपर) यह याद रखने की आसान विधि देती है कि जब जावा में वाइल्डकार्ड (सहप्रसरण और विरोधाभास के अनुरूप) का उपयोग करना है।

थ्रो क्लॉज़ में जेनरिक

चूँकि अपवाद स्वयं सामान्य नहीं हो सकते, सामान्य पैरामीटर थ्रो क्लॉज में दिखाई दे सकते हैं:

public <T extends Throwable> void throwMeConditional(boolean conditional, T exception) throws T {
    if (conditional) {
        throw exception;
    }
}

प्रकार मिटाने की समस्या

टाइप-शुद्धता के लिए संकलन-समय पर जेनेरिक की जाँच की जाती है। सामान्य प्रकार की जानकारी को प्रकार मिटाना नामक प्रक्रिया में हटा दिया जाता है। उदाहरण के लिए, List<Integer> गैर-जेनेरिक Listप्रकार में परिवर्तित कर दिया जाएगा, जिसमें सामान्यतः इच्छानुसार वस्तुएं सम्मिलित होती हैं। संकलन-समय जांच यह गारंटी देती है कि परिणामी कोड सही प्रकार का उपयोग करता है।

प्रकार के क्षरण के कारण, रन-टाइम पर प्रकार के पैरामीटर निर्धारित नहीं किए जा सकते। उदाहरण के लिए, जब रनटाइम पर ArrayList की जांच की जाती है, तो यह निर्धारित करने का कोई सामान्य विधि नहीं है कि, प्रकार मिटाने से पहले, यह ArrayList<Integer> था या ArrayList<Float> था। कई लोग इस प्रतिबंध से असंतुष्ट हैं। यह आंशिक दृष्टिकोण हैं। उदाहरण के लिए, व्यक्तिगत तत्वों की जांच यह निर्धारित करने के लिए की जा सकती है कि वे किस प्रकार के हैं; उदाहरण के लिए, यदि किसी ArrayList में Integer है, तो उस ArrayList को Integer के साथ पैरामीटराइज़ किया गया हो सकता है (चूँकि, इसे Integer के किसी भी पैरेंट, जैसे Number या Object) के साथ पैरामीटराइज़ किया गया हो सकता है।

इस बिंदु को प्रदर्शित करते हुए, निम्नलिखित कोड समान आउटपुट देता है:

final List<Integer> li = new ArrayList<>();
final List<Float> lf = new ArrayList<>();
if (li.getClass() == lf.getClass()) { // evaluates to true
    System.out.println("Equal");
}

प्रकार के क्षरण का अन्य प्रभाव यह है कि सामान्य वर्ग किसी भी तरह से, प्रत्यक्ष या अप्रत्यक्ष रूप से, Throwable वर्ग का विस्तार नहीं कर सकता है:

public class GenericException<T> extends Exception

इसके समर्थित न होने का कारण प्रकार का क्षरण है:

try {
    throw new GenericException<Integer>();
}
catch (GenericException<Integer> e) {
    System.err.println("Integer");
}
catch (GenericException<String> e) {
    System.err.println("String");
}

टाइप इरेज़र के कारण, रनटाइम को पता नहीं चलेगा कि कौन सा कैच ब्लॉक निष्पादित करना है, इसलिए यह कंपाइलर द्वारा निषिद्ध है।

जावा जेनेरिक सी++ टेम्पलेट्स से भिन्न हैं। उपयोग किए गए पैरामीटर प्रकारों की संख्या की परवाह किए बिना, जावा जेनेरिक जेनेरिक वर्ग या फलन का केवल संकलित संस्करण उत्पन्न करते हैं। इसके अतिरिक्त, जावा रन-टाइम वातावरण को यह जानने की आवश्यकता नहीं है कि किस पैरामीटरयुक्त प्रकार का उपयोग किया जाता है क्योंकि प्रकार की जानकारी संकलन-समय पर मान्य होती है और संकलित कोड में सम्मिलित नहीं होती है। परिणामस्वरूप, पैरामीटरयुक्त प्रकार के जावा क्लास को इंस्टेंट करना असंभव है क्योंकि इंस्टेंटेशन के लिए कंस्ट्रक्टर को कॉल की आवश्यकता होती है, जो कि प्रकार अज्ञात होने पर अनुपलब्ध है।

उदाहरण के लिए, निम्नलिखित कोड संकलित नहीं किया जा सकता:

<T> T instantiateElementType(List<T> arg) {
     return new T(); //causes a compile error
}

चूँकि रनटाइम पर प्रति जेनेरिक क्लास की केवल प्रतिलिपि होती है, स्थैतिक चर को क्लास के सभी उदाहरणों के बीच साझा किया जाता है, चाहे उनके प्रकार के पैरामीटर कुछ भी हों। परिणामस्वरूप, प्रकार पैरामीटर का उपयोग स्थिर चर की घोषणा में या स्थिर विधियों में नहीं किया जा सकता है।

जावा SE5 से पहले लिखे गए प्रोग्रामों के साथ बैकवर्ड संगतता बनाए रखने के लिए जावा में टाइप इरेज़र प्रयुक्त किया गया था।

सरणी से अंतर

जावा में सरणियों (आदिम सरणियों और Object सरणियों दोनों) और जेनेरिक के बीच कई महत्वपूर्ण अंतर हैं। दो प्रमुख अंतर, अर्थात् विचरण और रीफिकेशन के संदर्भ में अंतर।

सहप्रसरण, प्रतिप्रसरण और अपरिवर्तन

Main article: सहप्रसरण और प्रतिप्रसरण (कंप्यूटर विज्ञान)

जेनेरिक अपरिवर्तनीय हैं, जबकि सरणियाँ सहप्रसरण और प्रतिप्रसरण (कंप्यूटर विज्ञान) हैं। सरणियों जैसी गैर-जेनेरिक वस्तुओं की तुलना में जेनेरिक का उपयोग करने का यह लाभ है। विशेष रूप से, जेनरिक डेवलपर को कोड को ठीक करने के लिए विवश करने के लिए संकलन-समय अपवाद फेंककर रन टाइम अपवादों को रोकने में सहायता कर सकता है।

उदाहरण के लिए, यदि कोई डेवलपर Object[] ऑब्जेक्ट घोषित करता है और ऑब्जेक्ट को नए Long[]] ऑब्जेक्ट के रूप में इंस्टेंट करता है, तो कोई संकलन-समय अपवाद नहीं फेंका जाता है (क्योंकि एरे सहसंयोजक होते हैं)। इससे यह ग़लत धारणा बन सकती है कि कोड सही ढंग से लिखा गया है। चूँकि, यदि डेवलपर इस Long[] ऑब्जेक्ट में String जोड़ने का प्रयास करता है, तो प्रोग्राम ArrayStoreException फेंक देगा। यदि डेवलपर जेनेरिक का उपयोग करता है तो इस रन-टाइम अपवाद से पूरी तरह बचा जा सकता है।

यदि डेवलपर Collection<Object> ऑब्जेक्ट घोषित करता है और रिटर्न प्रकार ArrayList<Long> के साथ इस ऑब्जेक्ट का नया उदाहरण बनाता है, तो जावा कंपाइलर (सही ढंग से) असंगत प्रकारों की उपस्थिति को इंगित करने के लिए संकलन-समय अपवाद फेंक देगा (क्योंकि जेनेरिक हैं)। इसलिए, यह संभावित रन-टाइम अपवादों से बचा जाता है। इसके बजाय ArrayList<Object> ऑब्जेक्ट का उपयोग करके Collection<Object> का उदाहरण बनाकर इस समस्या को ठीक किया जा सकता है। जावा SE7 या बाद के संस्करणों का उपयोग करने वाले कोड के लिए, Collection<Object> को डायमंड ऑपरेटर का उपयोग करके ArrayList<> ऑब्जेक्ट के साथ त्वरित किया जा सकता है।

पुनःकरण

Main article: रीफिकेशन (कंप्यूटर विज्ञान)

ऐरे को पुनरीक्षित किया जाता है, जिसका अर्थ है कि ऐरे ऑब्जेक्ट रन-टाइम पर अपने प्रकार की जानकारी को प्रयुक्त करता है, जबकि जावा में जेनेरिक को पुन: संशोधित नहीं किया जाता है।

अधिक औपचारिक रूप से कहें तो, जावा में सामान्य प्रकार वाली वस्तुएं गैर-शोधन योग्य प्रकार हैं। गैर-शोधन योग्य प्रकार वह प्रकार है, जिसका रन-टाइम पर प्रतिनिधित्व में संकलन-समय पर इसके प्रतिनिधित्व की तुलना में कम जानकारी होती है।

जावा में सामान्य प्रकार वाली वस्तुएं प्रकार के क्षरण के कारण पुन:शोधन योग्य नहीं होती हैं। जावा केवल संकलन-समय पर प्रकार की जानकारी प्रयुक्त करता है। संकलन-समय पर प्रकार की जानकारी सत्यापित होने के बाद, प्रकार की जानकारी हटा दी जाती है, और रन-टाइम पर, प्रकार की जानकारी उपलब्ध नहीं होगी।

गैर-शोधन योग्य प्रकारों के उदाहरणों में List<T> और List<String> सम्मिलित हैं, जहाँ T सामान्य औपचारिक पैरामीटर है।

जेनेरिक पर प्रोजेक्ट

प्रोजेक्ट वल्लाह (जावा भाषा) जावा 10 से आगे के संभावित संस्करणों के लिए उत्तम जावा जेनेरिक और भाषा सुविधाओं को विकसित करने के लिए प्रायोगिक परियोजना है। संभावित संवर्द्धन में सम्मिलित हैं:

• सामान्य विशेषज्ञता, उदाहरण List<int>
• रिफाइड जेनेरिक; रनटाइम पर वास्तविक प्रकार उपलब्ध कराना।

यह भी देखें

• सामान्य प्रोग्रामिंग
• टेम्प्लेट मेटाप्रोग्रामिंग
• वाइल्डकार्ड (जावा)
• सी# और जावा की तुलना
• जावा और सी++ की तुलना

संदर्भ

• Bloch, Joshua (2018). "Effective Java: Programming Language Guide" (third ed.). Addison-Wesley. ISBN 978-0134685991.