जावा कंटेनर में ऑब्जेक्ट्स के कई प्रकार

Question

मैं जावा में जेनेरिक के बारे में सीख रहा हूं, और सोच रहा था कि क्या इसे खराब कोडिंग माना जाएगा।

यदि मैं ArrayList<Object> घोषित करता हूं तो मुझे पता है कि मैं किसी भी प्रकार की वस्तु को इस सूची में डाल सकता हूं, क्योंकि सभी ऑब्जेक्ट ऑब्जेक्ट से निकलते हैं। मुझे यह भी पता है कि जब मैं ArrayList.remove(index) पर कॉल करता हूं, तो ऑब्जेक्ट से निकाली गई वस्तु ऑब्जेक्ट का प्रकार है, और मुझे उस ऑब्जेक्ट के प्रकार को टाइप करना होगा जिसे मैं उपयोग करना चाहता हूं।

अब मान लीजिए कि मेरे पास Dog, Cat, और Car का ऑब्जेक्ट है। क्या सभी तीन वस्तुओं को सरणी में रखना बुरा होगा, क्योंकि वे समान वर्ग नहीं हैं?

Answer 1

हमें एक Collection

एक संग्रह की परिभाषा को संशोधित करते हैं - कभी कभी एक कंटेनर कहा जाता है - बस एक वस्तु है कि समूहों को एक ही इकाई में एक से अधिक तत्वों। संग्रह का उपयोग कुल डेटा को संग्रहीत करने, पुनर्प्राप्त करने, छेड़छाड़ करने और संवाद करने के लिए किया जाता है। आम तौर पर, वे डेटा आइटम का प्रतिनिधित्व करते हैं जो प्राकृतिक समूह बनाते हैं .... (जारी)।

बोल्ड शब्दों को देखें। आपको अपना जवाब देना चाहिए।

यदि आप ArrayList में ऑब्जेक्ट्स डालते हैं जो समान कार्यान्वयन से संबंधित नहीं हैं, तो आप निश्चित रूप से स्थितियों में समस्याएं आमंत्रित कर रहे हैं जब आप सूची से ऑब्जेक्ट पुनर्प्राप्त करना चाहते हैं और उन्हें उचित प्रकारों में टाइप करना चाहते हैं। तो आपको AVOID करना चाहिए।

ArrayList में Dog और Car की वस्तुओं को संग्रहीत करने पर विचार करें। फिर प्रत्येक ऑब्जेक्ट को संग्रहीत करने के लिए, आप कुछ विधि कॉल करना चाहते हैं, barkLoudly() कहें। अब, यह विधि Dog ऑब्जेक्ट के साथ ठीक काम करेगी। लेकिन जब इसे Car, बूउम पर बुलाया जाता है .... Exception उत्पन्न होगा।

Answer 2

मुझे लगता है कि जवाब "आमतौर पर, लेकिन हमेशा नहीं" होता है। कोडिंग में बहुत कठिन और तेज़ नियम नहीं हैं; यदि आप काफी मेहनत करते हैं तो आप हमेशा अपवाद पा सकते हैं। लेकिन यदि आप ऑब्जेक्ट को उस संग्रह से बाहर खींचते हैं जिसे आपको सही प्रकार पर डालना है, तो आमतौर पर यह एक डिज़ाइन त्रुटि होती है।

कोड बनाने का प्रयास करें ताकि आपके द्वारा काम की जाने वाली वस्तुओं के पास पहले से ही सही प्रकार हो, जो आप करना चाहते हैं। यदि आपको कास्ट करने की आवश्यकता नहीं है, तो ऑब्जेक्ट ठीक हो सकता है। यदि आपको कास्ट करने की ज़रूरत है, तो आपको शायद अपने डिजाइन पर पुनर्विचार करना चाहिए।

Answer 3

इस तरह के सभी मुद्दों से बचने के लिए डिज़ाइन वास्तव में खराब होगा, जेनरिक पेश किए गए थे। लेकिन वही आप नीचे उपयोग करके प्राप्त कर सकते हैं, बशर्ते आपके पास समान प्रकार की वस्तुएं हों।

बिल्ली और कुत्ते पशु

कार प्रदान करता है और बाइक वाहन

फैली लेकिन उपरोक्त दो बयानों मिश्रण नहीं है।

पशु वर्ग:

public abstract class Animal { 
    protected String name; 
} 

कुत्ता वर्ग:

public class Dog extends Animal { 
    public Dog(String name) { 
     this.name=name; 
    } 
} 

बिल्ली वर्ग:

public class Cat extends Animal { 
    public Cat(String name) { 
     this.name=name; 
    } 
} 

मुख्य वर्ग:

public class Main { 
    public static void main(String[] args) { 
     Cat Cat = new Cat("C"); 
     Dog Dog = new Dog("D"); 
     ArrayList<Animal> list = new ArrayList<Animal>(); 
     list.add(Cat); 
     list.add(Dog); 
    } 
} 

Answer 4

आप इस

चलें इस तरह से इसे देख, अगर एक हम एक सामान्य Object सिर्फ एक "बात" कहते हैं और आप एक बनाने के नहीं करना चाहिए (एन) (Array) सिर्फ "चीजें" की सूची तो आपके लिए कितना उपयोगी है? उन तीन चीजों को स्टोर करने के लिए जो एक सूची में आम तौर पर कुछ भी सामान्य नहीं हैं, समझ में नहीं आता है। कंटेनर जोड़े गए थे ताकि प्रोग्रामर के समान चीजों को संग्रहित कर सकें।

यदि हम इसे वास्तविक प्रोग्राम बिंदु के विपरीत के रूप में एक प्रोग्रामिंग दृष्टिकोण से अधिक देखें, तो इससे अधिक समस्याएं बढ़ती हैं। आपका कोड केवल एक क्रिया को करने का प्रयास कर सकता है जो केवल Car कर सकता है, संकलक यह नहीं मानता कि आपकी Dog कक्षा ने अभी turnOnEngine() पर प्रयास किया है, और ऐसी कोई त्रुटि फेंकता है जिसकी आपने अपेक्षा नहीं की थी।

तो संक्षेप में, संग्रह में असंबंधित वस्तुओं को जोड़ने का बुरा अभ्यास है।

Answer 5

यह इस बात पर निर्भर करता है कि आप List का उपयोग करना चाहते हैं।

आपको List के जेनेरिक प्रकार मान को अपनी आवश्यकताओं के अनुरूप सबसे अधिक प्रतिबंधित करने के लिए घोषित करना चाहिए, और इस तरह आप संकलन समय पर त्रुटियों को खत्म करने के लिए कंपाइलर से सबसे मजबूत जांच प्राप्त करते हैं।

ऐसे मामले हो सकते हैं जब आप वास्तव में List में किसी भी प्रकार की ऑब्जेक्ट्स को स्टोर करना चाहते हैं, तो आप List<Object> का उपयोग करेंगे। फिर, इस बात पर निर्भर करता है कि आप List और तत्वों के लिए क्या उपयोग करना चाहते हैं।

Answer 6

जेनरिक का उद्देश्य संकलक हमारे लिए सभी प्रकार की जांच कर रहा है। ताकि हमें कास्टिंग के बारे में चिंता करने की आवश्यकता न हो या याद रखना पड़े कि सूची में वास्तव में कौन से प्रकार हैं। तो जेनिक्स का उपयोग करने से दस्तावेज़ को निहित प्रकार को अधिक स्पष्ट बनाकर भी मदद करता है।

आप किए जा सकेंगे:

• जेनरिक का उपयोग नहीं और प्रत्येक प्रकार के लिए अलग-अलग सूचियों
• उपयोग जेनरिक साथ अपने स्वयं के प्रकार की जाँच लागू
• उपयोग जेनरिक (instanceof के साथ सुरक्षित downcasting द्वारा) संबंधित वर्ग के लिए एक अमूर्तता के साथ, उदाहरण के लिए: List<Animal>