आया, देखा, सामान्यीकृत: जावा जेनरिक में डूबा हुआ

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

संग्रह के साथ काम करें

मान लीजिए कि किसी बैंक को ग्राहक के खातों में बचत की मात्रा की गणना करने की आवश्यकता है। "जेनरिक" के आगमन से पहले, योग की गणना करने की विधि इस तरह दिखती है:

public long getSum(List accounts) {   long sum = 0;   for (int i = 0, n = accounts.size(); i < n; i++) {       Object account = accounts.get(i);       if (account instanceof Account) {           sum += ((Account) account).getAmount();       }   }   return sum; } 

हमने इसे खातों की सूची के माध्यम से प्रसारित, चलाया और जाँच की कि क्या इस सूची का तत्व वास्तव में Account वर्ग का एक उदाहरण है - अर्थात, उपयोगकर्ता का खाता। हमारे Account श्रेणी का प्रकार और getAmount विधि getAmount , जिसने इस खाते में राशि वापस कर दी। फिर उन्होंने इसे पूरा किया और कुल राशि लौटा दी। दो चरणों की आवश्यकता थी:

 if (account instanceof Account) { // (1) 

 sum += ((Account) account).getAmount(); // (2) 

यदि आप Account वर्ग से संबंधित नहीं हैं ( instanceof ), तो दूसरे चरण में एक ClassCastException संभव है - अर्थात, एक प्रोग्राम क्रैश। इसलिए, इस तरह की जांच अनिवार्य थी।

जेनरिक के आगमन के साथ, टाइप चेकिंग और कास्टिंग की आवश्यकता गायब हो गई है:

 public long getSum2(List<Account> accounts) {  long sum = 0;  for (Account account : accounts) {      sum += account.getAmount();  }  return sum; } 

अब विधि

 getSum2(List<Account> accounts) 

तर्क के रूप में स्वीकार करता है केवल वर्ग Account की वस्तुओं की एक सूची। यह प्रतिबंध विधि में ही इंगित किया गया है, इसके हस्ताक्षर में, प्रोग्रामर केवल किसी अन्य सूची को स्थानांतरित नहीं कर सकता है - केवल ग्राहक खातों की सूची।

हमें इस सूची से तत्वों के प्रकार की जांच करने की आवश्यकता नहीं है: यह विधि पैरामीटर के प्रकार के विवरण से निहित है

 List<Account> accounts 

( Account रूप में पढ़ा जा सकता है)। और कंपाइलर एक त्रुटि को फेंक देगा यदि कुछ गलत हो जाता है - अर्थात, अगर कोई इस पद्धति के लिए Account वर्ग के अलावा अन्य वस्तुओं की सूची को पारित करने की कोशिश करता है।

चेक की दूसरी पंक्ति में, आवश्यकता भी गायब हो गई। यदि आवश्यक हो, तो संकलन मंच पर casting जाएगी।

प्रतिस्थापन सिद्धांत

बारबरा लिस्कॉव का प्रतिस्थापन सिद्धांत ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में उपप्रकार की एक विशिष्ट परिभाषा है। लिसकोव का "सबटाइप" का विचार प्रतिस्थापन की अवधारणा को परिभाषित करता है: यदि S T का एक उपप्रकार है, तो प्रोग्राम में टाइप T वस्तुओं को इस कार्यक्रम के वांछित गुणों में कोई बदलाव किए बिना टाइप S की वस्तुओं द्वारा प्रतिस्थापित किया जा सकता है।

टाइप	उप-प्रकार
संख्या	पूर्णांक
सूची <ई>	ArrayList <E>
संग्रह <ई>	सूची <ई>
Iterable <E>	संग्रह <ई>

प्रकार / उपप्रकार संबंध उदाहरण

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

 Number n = Integer.valueOf(42); List<Number> aList = new ArrayList<>(); Collection<Number> aCollection = aList; Iterable<Number> iterable = aCollection; 

Integer Number का एक उपप्रकार है, इसलिए, प्रकार Number के चर n को मान दिया जा सकता है कि Integer.valueOf(42) विधि रिटर्न।

कोवरियनस, कंट्रोवर्सी और इनविरेन्स

पहला, थोड़ा सिद्धांत। Covariance एक ही क्रम में व्युत्पन्न प्रकारों में स्रोत प्रकारों की विरासत के पदानुक्रम का संरक्षण है। उदाहरण के लिए, यदि बिल्ली जानवरों का एक उपप्रकार है, तो <Cats> का सेट <पशु> के सेट का एक उपप्रकार है। इसलिए, प्रतिस्थापन के सिद्धांत को ध्यान में रखते हुए, कोई निम्नलिखित कार्य कर सकता है:

कई <पशु> = कई <बिल्लियां>

व्युत्पन्न प्रकारों में स्रोत प्रकारों के पदानुक्रम का उलटा है। उदाहरण के लिए, यदि बिल्ली का एक उपप्रकार है, तो सेट <पशु> <बिल्लियों के सेट का एक उपप्रकार है। इसलिए, प्रतिस्थापन के सिद्धांत को ध्यान में रखते हुए, कोई निम्नलिखित कार्य कर सकता है:

कई <बिल्लियों> = कई <पशु>

Invariance - व्युत्पन्न प्रकारों के बीच वंशानुक्रम की कमी। यदि बिल्ली जानवरों का एक उपप्रकार है, तो <Cats> का सेट <पशु> के सेट का उपप्रकार नहीं है और <पशु का सेट <कैट> का सेट का उपप्रकार नहीं है।

जावा में एरेव्स सहसंयोजक हैं । टाइप S[] T[] उप-प्रकार है T[] यदि S , T[] उप-प्रकार है T असाइनमेंट उदाहरण:

 String[] strings = new String[] {"a", "b", "c"}; Object[] arr = strings; 

हमने चर arr लिए स्ट्रिंग की एक सरणी को एक लिंक सौंपा, जिसका प्रकार « » । यदि सरणियाँ सहसंयोजक नहीं थीं, तो हम ऐसा नहीं कर पाएंगे। जावा आपको ऐसा करने की अनुमति देता है, कार्यक्रम त्रुटियों के बिना संकलन और चलाता है।

 arr[0] = 42; // ArrayStoreException.       

लेकिन अगर हम ऐरे वेरिएबल के जरिए ऐरे के कंटेंट को बदलने की कोशिश करते हैं और वहां नंबर 42 लिख देते हैं, तो हमें प्रोग्राम एक्जीक्यूटिव स्टेज पर ArrayStoreException , क्योंकि 42 एक स्ट्रिंग नहीं है, बल्कि एक नंबर है। यह जावा सरणियों के सहसंयोजक का दोष है: हम संकलन चरण में चेक प्रदर्शन नहीं कर सकते हैं, और रनटाइम में कुछ पहले ही टूट सकता है।

"जेनरिक" अपरिवर्तनीय हैं। यहाँ एक उदाहरण है:

 List<Integer> ints = Arrays.asList(1,2,3); List<Number> nums = ints; // compile-time error.      nums.set(2, 3.14); assert ints.toString().equals("[1, 2, 3.14]"); 

यदि आप पूर्णांक की एक सूची लेते हैं, तो यह प्रकार Number का उपप्रकार नहीं होगा, न ही कोई अन्य उपप्रकार। वह केवल स्वयं का एक उपप्रकार है। यानी List <Integer> एक List<Integer> और कुछ नहीं। कंपाइलर यह सुनिश्चित करेगा कि इंटेगर वर्ग की वस्तुओं की सूची के रूप में घोषित किए गए ints वैरिएबल में केवल इंटेगर क्लास की वस्तुएं हैं और कुछ नहीं। संकलन के चरण में, एक चेक किया जाता है, और हमारे रनटाइम में कुछ भी नहीं गिरेगा।

वाइल्डकार्ड

क्या जेनरिक हमेशा हमलावर होते हैं? नहीं। मैं उदाहरण दूंगा:

 List<Integer> ints = new ArrayList<Integer>(); List<? extends Number> nums = ints; 

यह सहसंयोजक है। List<Integer> - List<? extends Number> उपप्रकार List<? extends Number> List<? extends Number>

 List<Number> nums = new ArrayList<Number>(); List<? super Integer> ints = nums; 

यह विरोधाभासी है। List<Number> का एक उपप्रकार है List<? super Integer> List<? super Integer> ।

"? extends ..." जैसे "? extends ..." रिकॉर्ड "? extends ..." या "? super ..." को एक वाइल्डकार्ड या वाइल्डकार्ड कहा जाता है, जिसमें ऊपरी सीमा ( extends ) या एक कम बाउंड ( super ) होता है। List<? extends Number> List<? extends Number> वे ऑब्जेक्ट हो सकते हैं जिनकी कक्षा Number या Number से विरासत में मिली है। List<? super Number> List<? super Number> वे ऑब्जेक्ट्स हो सकते हैं जिनकी कक्षा Number या जिनकी Number एक इनहेरिटर ( Number से सुपरस्क्रिप्ट) है।

फैली बी - ऊपरी सीमा के साथ वाइल्डकार्ड सुपर बी - वाइल्डकार्ड एक कम बाउंड के साथ जहाँ B - सीमा का प्रतिनिधित्व करता है फॉर्म टी 2 <= टी 1 के रिकॉर्ड का मतलब है कि टी 2 द्वारा वर्णित प्रकारों का सेट टी 1 के रूप में वर्णित प्रकारों के सेट का सबसेट है। यानी संख्या <=? फैली हुई वस्तु ? फैली संख्या <=? फैली हुई वस्तु और ? सुपर ऑब्जेक्ट <=? सुपर नंबर

विषय की अधिक गणितीय व्याख्या

ज्ञान के परीक्षण के लिए कार्यों की एक जोड़ी:

1. नीचे दिए गए उदाहरण में संकलन-समय त्रुटि क्यों है? nums सूची में मैं किस मूल्य को जोड़ सकता हूं?

 List<Integer> ints = new ArrayList<Integer>(); ints.add(1); ints.add(2); List<? extends Number> nums = ints; nums.add(3.14); // compile-time error 

2. मुझे नीचे दी गई सूची से कोई आइटम क्यों नहीं मिल सकता है?

 public static <T> T getFirst(List<? super T> list) {  return list.get(0); // compile-time error } 

गेट एंड पुट प्रिंसिपल या पीईसीएस (प्रोड्यूसर एक्सटेंडेड कंज्यूमर सुपर)

ऊपरी और निचले सीमा के साथ वाइल्डकार्ड सुविधा प्रकारों के सुरक्षित उपयोग से संबंधित अतिरिक्त सुविधाएँ देती है। आप केवल एक प्रकार के चर से पढ़ सकते हैं, केवल दूसरे को लिख सकते हैं (अपवाद का extends करने के लिए null लिखने की क्षमता है और super लिए Object पढ़ें)। यह याद रखना आसान है कि कब कौन से वाइल्डकार्ड का उपयोग करना है, पीईसीएस सिद्धांत है - निर्माता उपभोक्ता सुपर का विस्तार करता है।

• यदि हमने एक वाइल्डकार्ड का विस्तार किया है , तो यह निर्माता है । वह केवल "उत्पादन" करता है, कंटेनर से एक तत्व प्रदान करता है, और वह कुछ भी स्वीकार नहीं करता है।
  
• अगर हमने सुपर के साथ वाइल्डकार्ड की घोषणा की, तो यह उपभोक्ता है । वह केवल स्वीकार करता है, लेकिन कुछ भी प्रदान नहीं कर सकता है।
  

उदाहरण के रूप में java.util.Collections वर्ग में प्रतिलिपि पद्धति का उपयोग करके वाइल्डकार्ड और पीईसीएस सिद्धांत का उपयोग करने पर विचार करें।

 public static <T> void copy(List<? super T> dest, List<? extends T> src) { … } 

विधि मूल src सूची से तत्वों को dest सूची में कॉपी करती है। src - वाइल्डकार्ड के साथ घोषित किया गया ? extends ? extends और निर्माता है, और dest वाइल्डकार्ड के साथ घोषित किया गया है ? super ? super और एक उपभोक्ता है। वाइल्डकार्ड के सहसंयोजक और विरोधाभासी को देखते हुए, आप nums सूची से तत्वों को nums सूची में कॉपी कर सकते हैं:

 List<Number> nums = Arrays.<Number>asList(4.1F, 0.2F); List<Integer> ints = Arrays.asList(1,2); Collections.copy(nums, ints); 

यदि हम गलती से कॉपी विधि के मापदंडों की गलती करते हैं और nums सूची से लेकर nums सूची में कॉपी करने की कोशिश करते हैं, तो कंपाइलर हमें ऐसा करने की अनुमति नहीं देगा:

 Collections.copy(ints, nums); // Compile-time error 

<?> और कच्चे प्रकार

नीचे एक वाइल्डकार्ड है जिसमें एक असीमित वाइल्डकार्ड है। हम सिर्फ <?> को बिना super या extends कीवर्ड के डालते हैं:

 static void printCollection(Collection<?> c) {  // a wildcard collection  for (Object o : c) {      System.out.println(o);  } } 

वास्तव में, ऐसा "असीमित" वाइल्डकार्ड अभी भी ऊपर से सीमित है। Collection<?> भी एक वाइल्डकार्ड है, जैसे " ? extends Object "। Collection<?> का एक रिकॉर्ड Collection<?> Collection<? extends Object> Collection<?> बराबर है Collection<? extends Object> Collection<? extends Object> , जिसका अर्थ है कि संग्रह में किसी भी वर्ग की वस्तुएं हो सकती हैं, क्योंकि जावा में सभी कक्षाएं Object से विरासत में Object - इसलिए प्रतिस्थापन को असीमित कहा जाता है।

यदि हम उदाहरण के लिए, प्रकार संकेत को छोड़ देते हैं, तो यहां:

 ArrayList arrayList = new ArrayList(); 

तब वे कहते हैं कि ArrayList Raw प्रकार के पैरामीटरित ArrayList <T> है । कच्चे प्रकारों का उपयोग करते हुए, हम जेनरिक के युग में वापस लौटते हैं और जानबूझकर सभी प्रकार के मापदंडों में निहित सुविधाओं को छोड़ देते हैं।

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

 ArrayList<String> strings = new ArrayList<>(); ArrayList arrayList = new ArrayList(); arrayList = strings; // Ok strings = arrayList; // Unchecked assignment arrayList.add(1); //unchecked call 

वाइल्डकार्ड कैप्चर

अब चलो एक विधि को लागू करने का प्रयास करें जो सूची के तत्वों को रिवर्स ऑर्डर में अनुमति देता है।

 public static void reverse(List<?> list); // ! public static void reverse(List<?> list) { List<Object> tmp = new ArrayList<Object>(list); for (int i = 0; i < list.size(); i++) {   list.set(i, tmp.get(list.size()-i-1)); // compile-time error } } 

संकलन त्रुटि हुई क्योंकि reverse विधि एक असीमित वाइल्डकार्ड वर्ण के साथ एक सूची लेता है <?> एक तर्क के रूप में।
<?> अर्थ है <? extends Object> <? extends Object> । इसलिए, पीईसीएस सिद्धांत के अनुसार, list producer । और producer ही तत्वों का उत्पादन करता है। और हम लूप के लिए set() विधि को कॉल करते हैं, अर्थात। list लिखने की कोशिश कर रहा है। और इसलिए हम जावा सुरक्षा के खिलाफ आराम करते हैं, जो हमें सूचकांक द्वारा कुछ मूल्य निर्धारित करने की अनुमति नहीं देता है।

क्या करें? Wildcard Capture पैटर्न हमारी मदद करेगा। यहां हम एक जेनेरिक rev विधि बनाते हैं। यह T एक चर के साथ घोषित किया जाता है T यह विधि T प्रकारों की एक सूची को स्वीकार करती है, और हम एक सेट बना सकते हैं।

 public static void reverse(List<?> list) { rev(list); } private static <T> void rev(List<T> list) { List<T> tmp = new ArrayList<T>(list); for (int i = 0; i < list.size(); i++) {   list.set(i, tmp.get(list.size()-i-1)); } } 

अब सब कुछ हमारे साथ संकलित होगा। यहां वाइल्डकार्ड कैप्चर किया गया। जब reverse(List<?> list) विधि को कहा जाता है reverse(List<?> list) , कुछ ऑब्जेक्ट्स (उदाहरण के लिए, तार या पूर्णांक) की एक सूची को एक तर्क के रूप में पारित किया जाता है। यदि हम इन वस्तुओं के प्रकार को पकड़ सकते हैं और इसे X एक चर में असाइन कर सकते हैं, तो हम यह निष्कर्ष निकाल सकते हैं कि T , X

आप यहां और यहां Wildcard Capture बारे में अधिक पढ़ सकते हैं।

निष्कर्ष

यदि आपको कंटेनर से पढ़ने की आवश्यकता है, तो ऊपरी सीमा के साथ एक वाइल्डकार्ड का उपयोग करें " ? extends "। यदि आपको कंटेनर को लिखने की आवश्यकता है, तो " ? super " की निचली सीमा के साथ वाइल्डकार्ड का उपयोग करें। यदि आपको रिकॉर्ड करने और पढ़ने की आवश्यकता है तो वाइल्डकार्ड का उपयोग न करें।

Raw प्रकार का उपयोग न करें! यदि प्रकार तर्क परिभाषित नहीं है, तो वाइल्डकार्ड <?> उपयोग करें।

चर प्रकार

जब हम कोण कोष्ठक में पहचानकर्ता को लिखते हैं, उदाहरण के लिए, <T> या <E> वर्ग या विधि की घोषणा करते समय, हम एक प्रकार का चर बनाते हैं। एक प्रकार का चर एक अयोग्य पहचानकर्ता है जिसे एक वर्ग या विधि के शरीर में एक प्रकार के रूप में इस्तेमाल किया जा सकता है। एक प्रकार का चर ऊपर बांधा जा सकता है।

 public static <T extends Comparable<T>> T max(Collection<T> coll) { T candidate = coll.iterator().next(); for (T elt : coll) {   if (candidate.compareTo(elt) < 0) candidate = elt; } return candidate; } 

इस उदाहरण में, अभिव्यक्ति T extends Comparable<T> , T extends Comparable<T> को परिभाषित करता है, जो T (एक प्रकार का चर) को परिभाषित करता है, जो T extends Comparable<T> प्रकार से ऊपर घिरा हुआ है। वाइल्डकार्ड के विपरीत, टाइप चर केवल शीर्ष पर सीमित हो सकते हैं (केवल extends )। super नहीं लिख सकता। इसके अलावा, इस उदाहरण में, T खुद पर निर्भर करता है, इसे recursive bound - एक पुनरावर्ती सीमा कहा जाता है।

यहाँ Enum वर्ग से एक और उदाहरण है:

 public abstract class Enum<E extends Enum<E>>implements Comparable<E>, Serializable 

यहाँ, Enum क्लास को E से टाइप किया जाता है, जो Enum<E> का एक उपप्रकार है।

एकाधिक सीमाएँ

Multiple Bounds - कई बाधाएँ। यह " & " वर्ण के माध्यम से लिखा गया है, अर्थात्, हम कहते हैं कि टाइप T एक चर द्वारा दर्शाए गए प्रकार को Object क्लास और Comparable इंटरफ़ेस द्वारा ऊपर से बाध्य किया जाना चाहिए।

 <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) 

रिकॉर्ड Object & Comparable<? super T> Object & Comparable<? super T> चौराहे के प्रकार को Multiple Bounds बनाता है। पहली सीमा - इस मामले में, Object - erasure लिए उपयोग किया जाता है, टाइप-मैशिंग प्रक्रिया। यह संकलन चरण में कंपाइलर द्वारा किया जाता है।

निष्कर्ष

एक प्रकार का चर केवल एक या अधिक प्रकारों के ऊपर सीमित किया जा सकता है। कई बाधाओं के मामले में, बायां बॉर्डर (पहला बाधा) ओवरराइटिंग की प्रक्रिया में उपयोग किया जाता है (टाइप एरर्योर)।

प्रकार मिटाना

टाइप एरासुर उन प्रकारों की मैपिंग है (संभवत: पैरामीटर किए गए प्रकार और प्रकार चर सहित) जो कभी भी पैरामीटर किए गए प्रकार या चर प्रकार नहीं होते हैं। हम लिखते हैं टाइप T मैशिंग के रूप में |T| ।

मैशिंग डिस्प्ले को निम्नानुसार परिभाषित किया गया है:

• पैरामीटर किए गए टाइपिंग को G < T1 , ..., Tn > है | जी |
• एक नेस्टेड प्रकार का परीक्षण करना टीसी है | टी | सी
• सरणी प्रकार को T पर अंकित करना [] है | टी | []
• एक प्रकार का वैरिएबल मैशिंग इसकी बाईं सीमा को मैशिंग कर रहा है
• किसी अन्य प्रकार को मैशिंग करना इस प्रकार का ही है

टाइप एरासुरे (टाइप मेशिंग) के निष्पादन के दौरान, कंपाइलर निम्नलिखित क्रियाएं करता है:

• यदि आवश्यक हो तो टाइप सुरक्षा प्रदान करने के लिए टाइप कास्टिंग जोड़ता है
• बहुरूपता को बनाए रखने के लिए ब्रिज तरीके उत्पन्न करता है

टी (प्रकार)	| टी | (मास्किंग प्रकार)
सूची <पूर्णांक>, सूची <स्ट्रिंग>, सूची <सूची <स्ट्रिंग >>	सूची
सूची <पूर्णांक> []	सूची []
सूची	सूची
पूर्णांक	पूर्णांक
पूर्णांक	पूर्णांक
<T तुलनात्मक का विस्तार करता है <T >>	तुलनीय
<T वस्तु और तुलनीय है <? सुपर टी >>	वस्तु
लिंक्ड कॉलेक्शन <ई> .नोड	LinkedCollection.Node

यह तालिका दिखाती है कि मैशिंग प्रक्रिया के दौरान विभिन्न प्रकार क्या बदल जाते हैं, टाइप एरासुर।

नीचे स्क्रीनशॉट में कार्यक्रम के दो उदाहरण हैं:


दोनों के बीच अंतर यह है कि एक संकलन-समय त्रुटि बाईं ओर होती है, और दाईं ओर सब कुछ त्रुटियों के बिना संकलित होता है। क्यों?

रेफर करने योग्य प्रकार

जावा में, हम कहते हैं कि एक प्रकार reifiable यदि इसकी जानकारी रन टाइम में पूरी तरह से सुलभ है। परिवर्तनीय प्रकारों में शामिल हैं:

• आदिम प्रकार ( इंट , लॉन्ग , बूलियन )
• असंगठित (गैर-सामान्य) प्रकार ( स्ट्रिंग , पूर्णांक )
• पैरामीटर प्रकार जिनके मापदंडों को अनबाउंड वाइल्डकार्ड (असीमित वाइल्डकार्ड वर्ण) के रूप में दर्शाया जाता है ( सूची <?> , संग्रह <?> ) ?
• कच्चा (विकृत) प्रकार ( सूची , ArrayList )
• एरर्स जिनके घटक रेफ़ेक्टिव प्रकार ( int [] , संख्या [] , सूची <?> [] , List [ ) हैं

क्यों कुछ प्रकारों के बारे में जानकारी उपलब्ध है लेकिन दूसरों के बारे में नहीं? तथ्य यह है कि संकलक द्वारा ओवरराइटिंग की प्रक्रिया के कारण, कुछ प्रकारों के बारे में जानकारी खो सकती है। यदि यह खो गया है, तो यह प्रकार अब अस्वीकार्य नहीं होगा। यानी यह रनटाइम पर उपलब्ध नहीं है। यदि उपलब्ध है - क्रमशः, पुन: प्रयोज्य।

सभी सामान्य प्रकारों को रन समय पर उपलब्ध नहीं कराने का निर्णय जावा प्रकार प्रणाली में सबसे महत्वपूर्ण और परस्पर विरोधी डिजाइन निर्णयों में से एक है। यह किया जाता है, सबसे पहले, मौजूदा कोड के साथ संगतता के लिए। मुझे माइग्रेशन कम्पैटिबिलिटी के लिए भुगतान करना पड़ा - रन टाइम में जेनेरिक प्रकार की प्रणाली की पूर्ण पहुँच संभव नहीं है।

कौन से प्रकार अस्वीकार्य नहीं हैं:

• प्रकार चर ( टी )
• निर्दिष्ट पैरामीटर प्रकार के साथ पैरामीटर प्रकार ( सूची <संख्या> एरियरिस्ट <स्ट्रिंग> , सूची <सूची <स्ट्रिंग >> )
• निर्दिष्ट ऊपरी या निचले बाउंड के साथ एक पैरामीटर प्रकार ( सूची <; विस्तार संख्या>, तुलनीय <? सुपर स्ट्रिंग> )। लेकिन यहाँ एक आरक्षण है: सूची <? फैली हुई वस्तु> - पुन: परिवर्तनीय नहीं है , लेकिन सूची <?> - पुन: प्रयोज्य

और एक और काम। नीचे दिए गए उदाहरण में एक पैरामीटर अपवाद क्यों नहीं बनाया जा सकता है?

 class MyException<T> extends Exception {  T t; } 

अनियंत्रित चेतावनी

हमारे आवेदन को Unchecked Warning तथाकथित Unchecked Warning उत्पादन कर सकता है - यह चेतावनी कि कंपाइलर हमारे प्रकारों के उपयोग के सुरक्षा स्तर को सही ढंग से निर्धारित नहीं कर सकता है। यह कोई गलती नहीं है, बल्कि एक चेतावनी है, इसलिए आप इसे छोड़ सकते हैं। लेकिन भविष्य में समस्याओं से बचने के लिए यह सब ठीक करना उचित है।

ढेर प्रदूषण

जैसा कि हमने पहले उल्लेख किया है, एक पैरामीटर प्रकार के एक चर के लिए कच्चे प्रकार के संदर्भ को निर्दिष्ट करने से चेतावनी "अनियंत्रित असाइनमेंट" की ओर अग्रसर होती है। यदि हम इसे अनदेखा करते हैं, तो " Heap Pollution " (ढेर प्रदूषण) नामक स्थिति संभव है। यहाँ एक उदाहरण है:

 static List<String> t() {  List l = new ArrayList<Number>();  l.add(1);  List<String> ls = l; // (1)  ls.add("");  return ls; } 

लाइन (1) पर, संकलक "अनियंत्रित असाइनमेंट" की चेतावनी देता है।

हमें "हीप प्रदूषण" का एक और उदाहरण देना होगा - जब हम मापदंडों वाली वस्तुओं का उपयोग करते हैं। नीचे दिया गया कोड स्निपेट स्पष्ट रूप से दिखाता है कि इसे Varargs प्रकार के तर्कों का उपयोग करने की अनुमति नहीं है, Varargs का उपयोग करने की विधि। इस स्थिति में, विधि पैरामीटर m है List<String>… , i.e. वास्तव में, टाइप List<String> के तत्वों की एक सरणी List<String> । stringLists दौरान प्रकारों को प्रदर्शित करने के नियम को देखते हुए, टाइप stringLists कच्ची सूचियों ( List[] ) की एक सरणी में बदल जाता है, अर्थात। असाइनमेंट किया जा सकता है Object[] array = stringLists; और फिर स्ट्रिंग्स (1) की सूची के अलावा किसी ऑब्जेक्ट को एक array लिखें, जो स्ट्रिंग (2) में ClassCastException को ClassCastException देगा।

 static void m(List<String>... stringLists) {  Object[] array = stringLists;  List<Integer> tmpList = Arrays.asList(42);  array[0] = tmpList; // (1)  String s = stringLists[0].get(0); // (2) } 

एक अन्य उदाहरण पर विचार करें:

 ArrayList<String> strings = new ArrayList<>(); ArrayList arrayList = new ArrayList(); arrayList = strings; // (1) Ok arrayList.add(1); // (2) unchecked call 

जावा लाइन (1) में असाइनमेंट की अनुमति देता है। पिछड़ी अनुकूलता के लिए यह आवश्यक है। लेकिन अगर हम add मेथड को लाइन (2) में निष्पादित करने का प्रयास करते add , तो हमें Unchecked call चेतावनी मिलती है - कंपाइलर हमें एक संभावित त्रुटि की चेतावनी देता है। वास्तव में, हम स्ट्रिंग्स की सूची में एक पूर्णांक जोड़ने की कोशिश कर रहे हैं।

प्रतिबिंब

हालांकि, संकलन के दौरान, पैरामीटर किए गए प्रकार एक प्रकार के क्षरण प्रक्रिया से गुजरते हैं, हम कुछ जानकारी का उपयोग कर सकते हैं।

• सभी प्रतिक्षेपक परावर्तन तंत्र के माध्यम से उपलब्ध हैं।
  
• क्लास फ़ील्ड्स, विधि मापदंडों और उनके द्वारा लौटाए गए मूल्यों के बारे में जानकारी परावर्तन के माध्यम से उपलब्ध है।
  

Reflection Reifiable , . , , , - , :

 java.lang.reflect.Method.getGenericReturnType() 

Generics java.lang.Class . :

 List<Integer> ints = new ArrayList<Integer>(); Class<? extends List> k = ints.getClass(); assert k == ArrayList.class; 

ints List<Integer> ArrayList< Integer> . ints.getClass() Class<ArrayLis> , List<Integer> List . Class<ArrayList> k Class<? extends List> , ? extends . ArrayList.class Class<ArrayList> .

निष्कर्ष

, Reifiable. Reifiable : , , , Raw , reifiable.

Unchecked Warnings « » .

Reflection , Reifiable. Reflection , .

Type Inference

« ». () . :

 List<Integer> list = new ArrayList<Integer>(); 

- Java 7 ArrayList :

 List<Integer> list = new ArrayList<>(); 

ArrayList – List<Integer> . type inference .

Java 8 JEP 101.
Type Inference. :

• (reduction)
  
• (incorporation)
  
• (resolution)
  

: , , — .
, . JEP 101 .

, :

 class List<E> {  static <Z> List<Z> nil() { ... };  static <Z> List<Z> cons(Z head, List<Z> tail) { ... };  E head() { ... } } 

List.nil() :

 List<String> ls = List.nil(); 

, List.nil() String — JDK 7, .

, , , :

 List.cons(42, List.nil()); //error: expected List<Integer>, found List<Object> 

JDK 7 compile-time error. JDK 8 . JEP-101, — . JDK 8 — :

 List.cons(42, List.<Integer>nil()); 

JEP-101 , , :

 String s = List.nil().head(); //error: expected String, found Object 

, . , JDK , :

 String s = List.<String>nil().head(); 

JEP 101 StackOverflow . , , 7- , 8- – ? :

 class Test {  static void m(Object o) {      System.out.println("one");  }  static void m(String[] o) {      System.out.println("two");  }  static <T> T g() {      return null;  }  public static void main(String[] args) {      m(g());  } } 

- JDK1.8:

   public static void main(java.lang.String[]);   descriptor: ([Ljava/lang/String;)V   flags: ACC_PUBLIC, ACC_STATIC   Code:     stack=1, locals=1, args_size=1        0: invokestatic  #6   // Method g:()Ljava/lang/Object;        3: checkcast     #7   // class "[Ljava/lang/String;"        6: invokestatic  #8   // Method m:([Ljava/lang/String;)V        9: return     LineNumberTable:       line 15: 0       line 16: 9 

0 g:()Ljava/lang/Object; java.lang.Object . , 3 («») , java.lang.String , 6 m:([Ljava/lang/String;) , «two».

- JDK1.7 – Java 7:

   public static void main(java.lang.String[]);   flags: ACC_PUBLIC, ACC_STATIC   Code:     stack=1, locals=1, args_size=1        0: invokestatic  #6   // Method g:()Ljava/lang/Object;        3: invokestatic  #7   // Method m:(Ljava/lang/Object;)V        6: return            LineNumberTable:       line 15: 0       line 16: 6 

, checkcast , Java 8, m:(Ljava/lang/Object;) , «one». Checkcast – , Java 8.

, Oracle JDK1.7 JDK 1.8 , Java, , .

, Java 8 , Java 7, :

 public static void main(String[] args) { m((Object)g()); } 

निष्कर्ष

Java Generics . , :

• Naftalin, Maurice; Wadler, Philip. Java Generics and Collections. O'Reilly Media. ISBN-13: 978-0596527754
  
• https://docs.oracle.com/javase/specs/jls/se8/html/index.html
  
• Java SE 8. Addison-Wesley. ISBN: 978-5-8459-1875-8
  

• Bloch, Joshua. Effective Java. Third Edition. Addison-Wesley. ISBN-13: 978-0-13-468599-1
  

, Java Generics.