दिलचस्प पोस्ट
हास्केल में अपवाद हैंडलिंग किसी ऑरेक्शन को किसी अर्रेसूची में जोड़ें और इसे बाद में संशोधित करें डबल-अंडरस्कोर के साथ पायथन विधि नाम ओवरराइड किया गया है? पायथन – पाइत्ज़ – समयक्षेत्र की सूची? जीआईटी कमांड को दिखाने के लिए कि कौन सा विशिष्ट फाइलें उपेक्षा की जाती हैं सभी mysql चयनित पंक्तियों को एक सरणी में प्राप्त करें पायथन 3 में "1000000000000000 सीमा में (1000000000000001)" इतनी तेज़ी क्यों है? यह फ़्लोटिंग-पॉइंट गणना अलग-अलग मशीनों पर अलग-अलग परिणाम क्यों देती है? कैसे जाँचें कि क्या फॉर्म तत्व रिक्त नहीं हैं? एंड्रॉइड / जावा के लिए "समय से पहले" पुस्तकालय html5 नए तत्व (हेडर, एनएवी, पादलेख, ..) IE में काम नहीं कर रहे हैं Jquery ui स्लाइडर्स के साथ नॉकआउट जेएस का उपयोग करना रेल 3 में परिवेश चर सेट करना (डेवलइस + ऑम्नियाथ) किसी VARCHAR फ़ील्ड में स्ट्रिंग की घटनाओं की संख्या की गणना करें? मैं वीआईएम से सी प्रोग्राम कैसे चलाऊँ?

जावा जेनेरिक – जेनेरिक को 2 इंटरफेस का विस्तार करने के लिए बनाएं

आप यह काम कैसे करते हैं:

public class Frankenstein<T extends IHuman, IMonster>{ } 

बनाने के बिना

 public interface Weirdo extends Ihuman, IMonster{ } 

संपादित करें

यह काम क्यों नहीं कर रहा है?

 public <T> void mapThis( Class<? extends MyClass<T>> key, Class<? extends T & IDisposable> value) { } 

मैं संकलक संदेश प्राप्त कर रहा हूँ Class<? extends T & IDisposable> Class<? extends T & IDisposable> एक त्रुटि के रूप में Class<? extends T & IDisposable>

Solutions Collecting From Web of "जावा जेनेरिक – जेनेरिक को 2 इंटरफेस का विस्तार करने के लिए बनाएं"

रेमियस ने पहले ही बताया कि आप अपने संपादन में जो पूछ रहे हैं वह संभव नहीं है। मैं सिर्फ इसलिए थोड़ा विस्तार करना चाहता हूं कि क्यों

आपको लगता है कि आप निम्न का उपयोग कर सकते हैं:

 public <T, U extends T & IDisposable> void mapThis( Class<? extends MyClass<T>> key, Class<? extends U> value ) { ... } 

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

एक प्रकार की चर का पालन अन्य सीमा से नहीं किया जा सकता है

मेरी समझ में मदद करने के लिए, मैं इस त्रुटि के बारे में विक्टर रुडोमेटोर्फ द्वारा एक ओरेकल ब्लॉग पोस्ट का उद्धरण करना चाहता हूं:

यह तथ्य हमेशा स्पष्ट नहीं होता है, लेकिन यह सच है। निम्नलिखित कोड को संकलित नहीं करना चाहिए:

interface I {}

class TestBounds <U, T extends U & I> {

}

क्योंकि जेएलएस अध्याय 4 प्रकार, मान, और चर खंड 4.4 प्रकार वैरिएबल कहता है: " बाउंड में या तो एक टाइप वैरिएबल, या क्लास या इंटरफ़ेस प्रकार टी संभवतः आगे इंटरफ़ेस प्रकार I 1 , …, I n द्वारा किया जाता है। " । तो कोई भी टी का उपयोग कर सकता है यू, टी कुछ क्लासेस और I को बढ़ाता है , लेकिन टी में यू एंड आई का विस्तार नहीं होता है यह नियम सभी प्रकार के मामलों पर लागू होता है जिसमें टाइप वैरिएबल और बाध्यताएं और कन्स्ट्रक्टर शामिल हैं।

इस प्रतिबंध के कारण निकटता से संबंधित पोस्ट में पता लगाया गया है: मैं कई सीमाओं के साथ एक प्रकार पैरामीटर में एक प्रकार तर्क का उपयोग क्यों नहीं कर सकता?

संक्षेप में, प्रतिबंध "कुछ अजीब स्थितियों को अस्तित्व में आने से रोकना" ( जेएलएस §4.9 ) के लिए लगाया गया था।

किस तरह की अजीब परिस्थितियों? क्रिस पोविनर्क का एक जवाब एक का वर्णन करता है:

[प्रतिबंध का एक कारण है] अवैध प्रकार निर्दिष्ट करने की संभावना है विशेष रूप से, विभिन्न मापदंडों के साथ दो बार एक सामान्य इंटरफ़ेस का विस्तार करना। मैं एक गैर-अनुवाचित उदाहरण के साथ नहीं आ सकता, लेकिन:

 /** Contains a Comparator<String> that also implements the given type T. */ class StringComparatorHolder<T, C extends T & Comparator<String>> { private final C comparator; // ... } void foo(StringComparatorHolder<Comparator<Integer>, ?> holder) { ... } 

अब holder.comparator एक Comparator<Integer> और एक Comparator<String>

क्रिस भी सन बग 4899305 को इंगित करता है , जो इस भाषा प्रतिबंध को चुनने वाला एक बग था। इसे बंद कर दिया गया था क्योंकि निम्नलिखित टिप्पणी के साथ ठीक नहीं होगा:

यदि एक टाइप वैरिएबल को टाइप वैरिएबल या (संभावित रूप से पैरामीटर वाला) इंटरफेस द्वारा पीछा किया जा सकता है, तो संभवतः अधिक पारस्परिक रूप से रिकर्सिव प्रकार के वेरिएबल होंगे, जो कि संभाल करने के लिए बहुत मुश्किल हैं जब कोई बाध्य बस एक पैरामीटर वाला प्रकार होता है, जैसे कि <S,R extends Comparable<S>> नतीजतन, सीमाएं अब बदलने नहीं जा रही हैं Javac और ग्रहण दोनों सहमत हैं कि S&T और S&Comparable<S> अवैध हैं

तो ये प्रतिबंध के पीछे के कारण हैं। सामान्य रूप से सामान्य तरीकों को संबोधित करते हुए (जो कि आपके सवाल की चिंताओं), मैं आगे यह कहना चाहूंगा कि उस प्रकार के निष्कर्ष सैद्धांतिक रूप से इस तरह की सीमा को वैसे भी बेकार होने का कारण होगा।

यदि हम उपरोक्त काल्पनिक हस्ताक्षर में घोषित प्रकार पैरामीटर की जांच करते हैं:

 <T, U extends T & IDisposable> 

कॉलर संभालने के लिए स्पष्ट रूप से T और U निर्दिष्ट नहीं है, यह निम्न करने के लिए कम किया जा सकता है:

 <T, U extends Object & IDisposable> 

या बस यह (सूक्ष्म अंतर है, लेकिन यह एक और विषय है ):

 <T, U extends IDisposable> 

इसका कारण यह है कि T पास कोई सीमा नहीं है, इसलिए कोई भी तर्क नहीं है कि किस प्रकार के तर्कों को पारित किया जाता है, T हमेशा कम से कम Object को हल कर सकता है, और फिर U बाद भी।

चलिए वापस चलिए और कहते हैं कि T बाउंडेड है:

 <T extends Foo, U extends T & IDisposable> 

इसे उसी तरीके से कम किया जा सकता है ( Foo क्लास या इंटरफ़ेस हो सकता है):

 <T extends Foo, U extends Foo & IDisposable> 

इस तर्क के आधार पर, जो सिंटैक्स आप हासिल करने की कोशिश कर रहे हैं वह निरर्थक है जहां तक ​​कॉलर को अधिक विशिष्ट तर्कों पर सीमित करना है।

प्री-जावा 8 परिशिष्ट:

जावा 8 से पहले, आप जो करने की कोशिश कर रहे हैं उसके लिए उपयोग का मामला है। कंपाइलर सामान्य तरीके प्रकार पैरामीटर का अनुमान कैसे करता है, मेरी उपरोक्त तर्क खिड़की से बाहर जाने के साथ एक सीमा के कारण। निम्नलिखित सामान्य विधि लें:

 class MyClass { static <T> void foo(T t1, T t2) { } } 

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

 MyClass.foo("asdf", 42); // legal 

यहाँ, T Object लिए अनुमान लगाया गया है – यह mapThis सरल बनाने के बारे में पहले तर्क के साथ मेल खाता mapThis प्रकार पैरामीटर इच्छित प्रकार जांच को प्राप्त करने के लिए आपको मैन्युअल रूप से प्रकार पैरामीटर निर्दिष्ट करना होगा:

 MyClass.<String>foo("asdf", 42); // compiler error 

हालांकि, और यहां जहां आपके उपयोग के मामले में आने लगते हैं, यह अलग-अलग प्रकार के मापदंडों के साथ अलग-अलग बात है, जिसमें सीधा सीमाएं हैं:

 class MyClass { static <T, U extends T> void foo(T t, U u) { } } 

अब यह कॉल त्रुटियां:

 MyClass.foo("asdf", 42); // compiler error 

तालिकाओं को बदल दिया गया है – हमें इसे संकलित करने के लिए मैन्युअल रूप से टाइप पैरामीटर को आराम करना है:

 MyClass.<Object, Object>foo("asdf", 42); // legal 

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

हालांकि, इस समस्या को जावा 8 में तय किया गया है, और MyClass.foo("asdf", 42) अब बिना किसी त्रुटि के संकलित है (यह इंगित करने के लिए रीजेंट के लिए धन्यवाद)।

मैंने सोचा था कि मैं अपने हैक साझा करेगा कि मैं इन (बहुत दुर्लभ) स्थितियों में उपयोग करता हूं:

  /** * This is a type-checking method, which gets around Java's inability * to handle multiple bounds such as "V extends T & ContextAware<T>". * * @param value initial value, which should extends T * @param contextAware initial value, which should extend ContextAware<T> * @return a new proxy object */ public T blah(T value, ContextAware<T> contextAware) { if (value != contextAware) { throw new IllegalArgumentException("This method expects the same object for both parameters."); } return blah(value); } 

इसलिए प्रत्येक चीज के लिए एक ही ऑब्जेक्ट की ज़रूरत है जिसे आप संतुष्ट करने की कोशिश कर रहे हैं, आप संकलन-समय की जांच कर सकते हैं और एकल ऑब्जेक्ट जो सब कुछ करता है बेशक, प्रत्येक पैरामीटर में समान ऑब्जेक्ट पास करने के लिए यह थोड़ा मूर्खतापूर्ण है, लेकिन मैं इसे 'आंतरिक' कोड में काफी सुरक्षित और आराम से करता हूं।