सर्वश्रेष्ठ अभ्यास: बाल कन्स्ट्रक्टर में माता-पिता को बाल नोड जोड़ना या नहीं?

Question

मैं कुछ कोड के साथ काम कर रहा हूं जो बच्चे के कन्स्ट्रक्टर में अपने माता-पिता को एक बच्चे नोड जोड़ता है। कोड इस तरह दिखता है:

कक्षा:

class Node1 { 
    public Node1(Node1 parent, String name) { 
    if(parent != null) { 
     parent.add(this); 
    } 
    this.parent = parent; 
    } 

    private void add(Node1 child) { 
    children.add(child); 
    } 
} 

उपयोग:

Node1 parent = new Node1(null, "parent"); 
Node1 child1 = new Node1(parent, "child1"); 
Node1 child2 = new Node1(parent, "child2"); 

यह इस तरह से लागू करने क्लास Node1 के उपयोगकर्ता द्वारा स्पष्ट रूप से चाइल्ड नोड जोड़ने की जरूरत नहीं है (कम कोड) इसके माता-पिता के लिए और आपने गारंटी दी है कि एक बच्चे नोड के माता-पिता हैं।

मैं व्यक्तिगत रूप से इस तरह यह लिखा नहीं होता है, लेकिन अधिक की तरह निम्नलिखित:

class Node2 { 
    public Node2(String name) { 
    } 

    public void add(Node2 child) { 
    children.add(child); 
    child.setParent(this); 
    } 
} 

Node2 parent = new Node2("parent"); 
Node2 child1 = new Node2("child1"); 
parent.add(child1); 
Node2 child2 = new Node2("child2"); 
parent.add(child2); 

तो मेरे सवाल है, यह एक अच्छा विचार इसे लागू करने के रूप में कक्षा Node1 में दिखाया गया है या वहाँ किसी भी हो रहा है इस तरह से करने के लिए आपत्तियां? या क्या कोई तर्क नहीं है कि एक दूसरे से बेहतर क्यों है?

Answer 1

मुझे व्यक्तिगत रूप से पहले उदाहरण पसंद नहीं हैं क्योंकि आप एक नोड जोड़ रहे हैं जो अभी तक "तैयार" नहीं है (क्योंकि कन्स्ट्रक्टर निष्पादित नहीं हुआ है)। ज्यादातर मामलों में यह ठीक काम करेगा, लेकिन चरम मामलों में आप कीड़े हो सकती हैं जो खोजने में काफी मुश्किल होती हैं।

Answer 2

मुझे लगता है कि दोनों कार्यान्वयन ठीक हैं।

प्रश्न यह है कि आप इस वर्ग का उपयोग कैसे करेंगे: क्या आप पहले नोड्स की एक सूची बनायेंगे और फिर अपने रिश्तों को जोड़ना शुरू करेंगे या आप इसे अपने उदाहरण में जैसे व्यवस्थित तरीके से करेंगे?

दूसरा समाधान अधिक लचीलापन प्रदान करता है, भले ही आप कभी भी सुपरक्लास के रूप में नोड 1 का उपयोग नहीं करना चाहते हैं, तो आप कन्स्ट्रक्टर हस्ताक्षर से बाध्य नहीं हैं।

Answer 3

मैं दूसरे मामले का उपयोग करता हूं, तब मैं बाद में बच्चों को जोड़ने में सक्षम हूं लेकिन न केवल निर्माता में।

Answer 4

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

Answer 5

मुझे पहले मामले को पसंद नहीं है - मूल वस्तु को पारित करके जादुई रूप से संशोधित किया गया है - आपको यह समझने के लिए कोड या दस्तावेज़ पढ़ना होगा। केवल माता-पिता में गुज़रने का तात्पर्य यह है कि बच्चा माता-पिता को जानता है - यह नहीं कि बच्चे को माता-पिता की आंतरिक सूची में भी जोड़ा जाता है।

दूसरा उदाहरण बेहतर है। तुम भी 'जोड़ें' आपरेशन से बच्चे लौट सकते हैं आपरेशन की तरह चेनिंग अनुमति देने के लिए: कि setParent (

class Node1 { 
    public Node1(String name, Node1 parent = null) { 
    this.name = name; 
    // etc., do initialization 

    if(parent != null) 
     parent.add(this); 
    } 

    private void add(Node1 child) { 
    child.setParent(this); 
    children.add(child); 
    } 
} 

नोट:

Node2 child = parent.add(new Node2()); 

Answer 6

मैं क्यों सुविधा के लिए दो दृष्टिकोण गठबंधन करने के लिए नहीं कोई कारण नहीं देखते हैं) या तो बच्चे को पहले से ही अपने माता-पिता के सेट होने पर अपवाद फेंक देना चाहिए, या अपने माता-पिता की बाल सूची से ठीक से हटा देना चाहिए।

Answer 7

अपने पहले नमूने में सबसे पहले खराब है: अगर (मूल = अशक्त!) { क्योंकि आप पेड़ की जड़ बनाने के लिए एक अवसर होता है इस चेक जरूरत है, लेकिन दो राज्य पैरामीटर बदसूरत लग रहा है।

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

Answer 8

मैं केवल कार्यान्वयन # 1 पसंद करूंगा जब एक बच्चे नोड के साथ माता-पिता नोड होना बिल्कुल जरूरी हो। इस मामले में, क्लाइंट कोड के लिए Node1.add (Node1 बच्चा) को कॉल को छोड़ने के लिए यह संभव है कि बाद में त्रुटियों का कारण बन जाए।

मैं अन्यथा कार्यान्वयन # 2 पसंद करते हैं क्योंकि यह स्पष्ट है

Node1 parent = new Node1(); 
Node1 child = new Node1(); 
parent.add(child);