दिलचस्प पोस्ट
मैं stdin फ्लश करने में सक्षम नहीं हूँ आईओएस लैंडस्केप-आईओएस 7 आर 4 इमेज एसेट के लिए कोई लॉन्च नहीं है I एंड्रॉइड के लिए एसक्यूएलटी एन्क्रिप्शन जावा विधि को रिक्त तर्क के साथ प्रेषण जेएसन प्रतिक्रिया के लिए रूट तत्व जोड़ना (डीजेंगो-बाकी-फ्रेमवर्क) नष्ट करें और फिर एक ही चर का उपयोग कर नए ऑब्जेक्ट का निर्माण करें संसाधन अधिग्रहण से क्या मतलब है आरंभिकरण (आरएआईआई) है? मैं क्यों नहीं कर सकता <img src = "C: /localfile.jpg">? मैं एक प्रोग्राम में पायथन संस्करण की जांच कैसे कर सकता हूं जो नई भाषा सुविधाओं का उपयोग करता है? मैं जावा में एक सरणी से ऑब्जेक्ट कैसे निकालूं? एक अन्य थ्रेड से यूनिटी एपीआई का उपयोग करें या मुख्य थ्रेड में फ़ंक्शन कॉल करें OS X पर sem_init AngularJS का उपयोग करके पूरे पृष्ठ को पुनः लोड या पुन: रेंडर कैसे करें किसी भी तरह से एक WPF पाठब्लॉक चयन करने योग्य है? जावा स्ट्रिंग काम नहीं बदले

आप एक सीमित वाइल्डकार्ड जेनेरिक में क्यों नहीं एकाधिक इंटरफेस कर सकते हैं?

मुझे पता है कि जावा के सामान्य प्रकारों के सभी प्रकार के काउंटर-सहज ज्ञान युक्त गुण हैं। यहाँ एक विशेष रूप से मुझे समझ में नहीं आ रहा है, और जिसे मैं उम्मीद कर रहा हूं कोई मुझे समझा सकता है जब किसी वर्ग या इंटरफ़ेस के लिए एक प्रकार पैरामीटर निर्दिष्ट करते हैं, तो आप इसे बाध्य कर सकते हैं ताकि इसे public class Foo<T extends InterfaceA & InterfaceB> साथ कई इंटरफेस को कार्यान्वित कर सकें public class Foo<T extends InterfaceA & InterfaceB> हालांकि, यदि आप किसी वास्तविक ऑब्जेक्ट को इंस्टाज़ कर रहे हैं, तो यह अब और काम नहीं करेगा। List<? extends InterfaceA> List<? extends InterfaceA> ठीक है, लेकिन List<? extends InterfaceA & InterfaceB> List<? extends InterfaceA & InterfaceB> संकलन करने में विफल रहता है निम्नलिखित पूर्ण स्निपेट पर विचार करें:

 import java.util.List; public class Test { static interface A { public int getSomething(); } static interface B { public int getSomethingElse(); } static class AandB implements A, B { public int getSomething() { return 1; } public int getSomethingElse() { return 2; } } // Notice the multiple bounds here. This works. static class AandBList<T extends A & B> { List<T> list; public List<T> getList() { return list; } } public static void main(String [] args) { AandBList<AandB> foo = new AandBList<AandB>(); // This works fine! foo.getList().add(new AandB()); List<? extends A> bar = new LinkedList<AandB>(); // This is fine too // This last one fails to compile! List<? extends A & B> foobar = new LinkedList<AandB>(); } } 

ऐसा लगता है कि bar की शब्दावली अच्छी तरह से परिभाषित होनी चाहिए – मैं सिर्फ एक के बजाय दो प्रकार के एक चौराहे को अनुमति देकर प्रकार-सुरक्षा के किसी भी नुकसान के बारे में नहीं सोच सकता। मुझे यकीन है कि हालांकि एक स्पष्टीकरण है। क्या किसी को पता है कि यह क्या है?

Solutions Collecting From Web of "आप एक सीमित वाइल्डकार्ड जेनेरिक में क्यों नहीं एकाधिक इंटरफेस कर सकते हैं?"

दिलचस्प है, इंटरफ़ेस java.lang.reflect.WildcardType की तरह लगता है कि यह वाइल्डकार्ड एआरजी के लिए ऊपरी सीमा और निचली सीमाओं का समर्थन करता है; और प्रत्येक में कई सीमाएं हो सकती हैं

 Type[] getUpperBounds(); Type[] getLowerBounds(); 

यह जिस तरह से भाषा की अनुमति देता है उससे परे है। स्रोत कोड में एक छिपी हुई टिप्पणी है

 // one or many? Up to language spec; currently only one, but this API // allows for generalization. 

इंटरफ़ेस के लेखक यह सोचते हैं कि यह एक आकस्मिक सीमा है।

आपके प्रश्न का डिब्बाबंद जवाब है, जेनेरिक पहले से बहुत जटिल है क्योंकि यह है; अधिक जटिलता जोड़ने से अंतिम पुआल साबित हो सकता है

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

एक परेशानी मुझे पता है कि प्रकार अनुमान में होगा। मौजूदा निष्कर्ष नियम केवल अंतरण प्रकारों के साथ सौदा नहीं कर सकते हैं। बाधा A&B << C को कम करने का कोई नियम नहीं A&B << C अगर हम इसे कम कर चुके हैं

  A<<C or A<<B 

किसी भी मौजूदा अनुमान इंजन को इस तरह के विभाजन की अनुमति देने के लिए बड़े ओवरहाल के माध्यम से जाना पड़ता है। लेकिन असली गंभीर समस्या यह है कि यह कई समाधानों की अनुमति देता है, लेकिन किसी एक को पसंद करने के लिए कोई औचित्य नहीं है।

हालांकि, सुरक्षा को टाइप करने के लिए अनुमान जरूरी नहीं है; हम इस मामले में अनुमान लगाने से इंकार कर सकते हैं, और प्रोग्रामर को स्पष्ट रूप से टाइप तर्कों को भरने के लिए कह सकते हैं। इसलिए, अनुमान में कठिनाई इंटरसेक्शन प्रकारों के खिलाफ एक मजबूत तर्क नहीं है।

जावा भाषा विशिष्टता से :

4.9 पर्चे प्रकार एक प्रतिच्छेदन प्रकार फॉर्म T1 और … और Tn, n> 0 लेता है, जहां तिवारी, 1in, प्रकार अभिव्यक्तियाँ हैं। कैप्चर रूपांतरण (§5.1.10) और प्रकार अनुमान (§15.12.2.7) की प्रक्रियाओं में प्रतिच्छेदन प्रकार उत्पन्न होते हैं। एक प्रोग्राम के भाग के रूप में सीधे एक प्रतिच्छेदन प्रकार लिखना संभव नहीं है; कोई वाक्यविन्यास इस का समर्थन नहीं करता है एक प्रतिच्छेदन प्रकार के मूल्य उन ऑब्जेक्ट हैं जो 1in के लिए सभी प्रकार के टाई के मान हैं।

तो यह क्यों समर्थित नहीं है? मेरा अनुमान है, आपको ऐसी चीज़ों के साथ क्या करना चाहिए? – मान लीजिए कि यह संभव था:

 List<? extends A & B> list = ... 

तो फिर क्या करना चाहिए

 list.get(0); 

वापसी? A & B रिटर्न वैल्यू को कैप्चर करने के लिए कोई सिंटैक्स नहीं है ऐसी सूची में कुछ जोड़ना संभव नहीं होगा, इसलिए यह मूल रूप से बेकार है।

कोई समस्या नहीं … बस विधि हस्ताक्षर में आपको आवश्यक प्रकार की घोषणा करें

यह संकलित:

 public static <T extends A & B> void main(String[] args) throws Exception { AandBList<AandB> foo = new AandBList<AandB>(); // This works fine! foo.getList().add(new AandB()); List<? extends A> bar = new LinkedList<AandB>(); // This is fine too List<T> foobar = new LinkedList<T>(); // This compiles! } 

अच्छा प्रश्न। मुझे यह पता लगाने में कुछ देर लग गई।

अपने केस को सरल बनाने की कोशिश करें: आप ऐसा करने की कोशिश कर रहे हैं जैसे कि आप एक वर्ग की घोषणा करते हैं जो 2 इंटरफेस बढ़ाता है, और उसके बाद एक वेरिएबल जो उस प्रकार के 2 इंटरफेस के रूप में है, कुछ ऐसा है:

  class MyClass implements Int1, Int2 { } Int1 & Int2 variable = new MyClass() 

बेशक, अवैध और यह आप जेनेटिक्स के साथ करने की कोशिश के बराबर है। आप क्या करने की कोशिश कर रहे हैं:

  List<? extends A & B> foobar; 

लेकिन फिर, फ़ॉबर का उपयोग करने के लिए, आपको इस तरह से दोनों इंटरफेस के एक चर का उपयोग करना होगा :

  A & B element = foobar.get(0); 

जो जावा में कानूनी नहीं है इसका अर्थ है, आप सूची के तत्वों को एक साथ 2 प्रकारों की मधु के रूप में घोषित कर रहे हैं, और यहां तक ​​कि अगर हमारे दिमाग भी इससे निपट सकते हैं, तो जावा भाषा नहीं कर सकती।

इसके लिए क्या फायदे हैं: अगर कोई इस पर सोच रहा है क्योंकि वे वास्तव में इसका इस्तेमाल करना चाहते हैं, तो मैंने एक इंटरफ़ेस परिभाषित करके इसके आसपास काम किया है जिसमें सभी इंटरफेस और कक्षा में सभी तरीकों का संघ शामिल है, जिनके साथ मैं काम कर रहा हूं। यानी मैं निम्नलिखित करने की कोशिश कर रहा था:

 class A {} interface B {} List<? extends A & B> list; 

जो अवैध है – तो इसके बजाय मैंने ऐसा किया:

 class A { <A methods> } interface B { <B methods> } interface C { <A methods> <B methods> } List<C> list; 

यह अभी भी कुछ के रूप में List<? extends A implements B> रूप में टाइप करने में सक्षम होने के रूप में उपयोगी नहीं है List<? extends A implements B> List<? extends A implements B> , उदाहरण के लिए अगर कोई ए या बी के तरीकों को जोड़ता है या हटाता है, तो सूची का टाइपिंग स्वतः अपडेट नहीं होगा, इसके लिए सी में मैन्युअल बदलाव की आवश्यकता होती है। लेकिन यह मेरी आवश्यकताओं के लिए काम करता है