जावा: प्रत्येक पाश के लिए, पुनरावृत्ति से अधिक विस्तारित ऑब्जेक्ट

Question

मेरे प्रश्न बहुत ही सरल हो सकता है,

मैं कुछ भीतरी क्षेत्रों, setters और getters के साथ एक कक्षा Result है।

इसके अतिरिक्त, मेरे पास Special1Result है जो Result फैलाता है और इसमें कुछ और फ़ील्ड और Special2Result कुछ और डेटा शामिल हैं।

अलग वर्ग Dispatcher में, मैं निम्नलिखित विधि लिखा है:

processResults(List<? extends Result> results), जिसके साथ ही परिचित है Result (मैं अगर वहाँ विस्तारित परिणाम वस्तु में विशिष्ट क्षेत्र है क्वेरी करने के लिए इस विधि की जरूरत है - मैं एनोटेशन का उपयोग कर रहा हूँ)। for (Result res : results) {}

तो मेरे सवाल का क्या है:

तो मैं बढ़ाया के लिए-प्रत्येक पाश का उपयोग करने का फैसला किया है? मैं वेब पर खोजने की कोशिश कर रहा हूं कि इसे विस्तारित वस्तुओं के लिए लूप के लिए कैसे लिखना है, उदा। इस for (? extends Results res: results){}

की तरह कुछ के लिए यह संभव है? इसे लिखने का सही तरीका कैसा है?

Answer 1

मैं वेब पर खोजने की कोशिश कर रहा हूं कि इसे विस्तारित वस्तुओं के लिए लूप के लिए कैसे लिखना है, उदा। इस

for (? extends Results res: results){} 

की तरह कुछ नहीं, यह संभव नहीं है: आप स्थिर रन-टाइम में गतिशील रूप से आपूर्ति की आइटम टाइप नहीं कर सकते।

यह कैसे लिखने के लिए सही तरीका क्या है?

आप पहले से ही कर रहे हैं:

for (Results res: results) { 
} 

आप Special2Result के लिए परीक्षण करने के लिए है कि लूप के अंदर, आप यह कर सकते करना चाहते हैं, लेकिन आम तौर पर यह बताता है कि अपने डिजाइन सुधार किया जा सकता। आपके उप-वर्गों के लिए विशेष उपचार के विवरण छिपाने के लिए Visitor Pattern जैसे डबल प्रेषण की एक प्रणाली का उपयोग करना बेहतर विकल्प है।

Answer 2

आपको List<? extends Result> के बारे में पता है कि प्रत्येक तत्व Result होगा - तो यह सब आप लूप सिंटैक्स के लिए बढ़ाए गए में डाल सकते हैं।

आप सदस्य हैं जिसमें Result में घोषित नहीं कर रहे हैं की जरूरत है, तो आप पाश अंदर कास्ट करने के लिए की आवश्यकता होगी:

for (Result result : results) { 
    if (result instanceof CleverResult) { 
     CleverResult clever = (CleverResult) result; 
     // Use clever here 
    } 
} 

अगर आप एक बढ़ाया का उपयोग नहीं कर रहे थे लिखते हैं क्या के बारे में सोचो लूप के लिए - आपको अभी भी कलाकार लिखना होगा, है ना?

बेशक, यदि आपको पता है कि सूची वास्तव में में केवल एक विशिष्ट प्रकार हो, तो आप हमेशा लूप में बिना शर्त तरीके से डाले जा सकते हैं।

Answer 3

जावा प्रकार विलोपन है - संग्रह में से ठोस प्रकार पैरामीटर रनटाइम पर मौजूद नहीं हैं।

तो अगर आप एक सूची है, जावा संकलक यह सुनिश्चित करेंगे कि कोई कोड की सूची है कि परिणाम के एक उपवर्ग नहीं है में कुछ भी डाल देंगे।

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

Answer 4

चूंकि आपके ठोस उपन्यास केवल फ़ील्ड की प्रकृति से भिन्न होते हैं, इसलिए मैं आपको सरल बहुरूपता से लाभ उठाने का सुझाव दूंगा।

आप एक Result इंटरफ़ेस/सार वर्ग एक execute() विधि वर्ग के रूप में कई वर्गों या उपवर्गों द्वारा कार्यान्वित के रूप में आप खुद को ऐसा करने के लिए कार्रवाई युक्त जरूरत है परिभाषित करने के साथ खत्म हो जाएगा।

इसलिए, अपने ग्राहक कोड केवल इस्तेमाल कर सकते हैं:

for (Result res : results){ //results being as a List<Result> type 
    res.execute(); 
}