दो अपरिवर्तनीय वस्तुओं को बनाने का कोई अच्छा तरीका एक दूसरे को संदर्भित करता है?

Question

इन दोनों जावा वर्गों लें:

class User { 
    final Inventory inventory; 
    User (Inventory inv) { 
     inventory = inv; 
    } 
} 

class Inventory { 
    final User owner; 
    Inventory (User own) { 
     owner = own; 
    } 
} 

वहाँ किसी भी तरह से without using reflection* इस बंद को खींचने के लिए है? मुझे वास्तव में यह उम्मीद नहीं है, लेकिन यह पूछने में कोई दिक्कत नहीं हो सकती है।

अद्यतन: बाईटकोड निर्माण में के बाद से दो चरणों (1. आवंटित वस्तु, 2. कॉल निर्माता **) इस हो सकता है (ab) हस्तलिखित बाईटकोड या एक कस्टम संकलक के साथ, यह करने के लिए इस्तेमाल किया गया है? मैं पहले दोनों ऑब्जेक्ट्स के लिए चरण 1 करने के बारे में बात कर रहा हूं, फिर चरण 1 से संदर्भों का उपयोग करके दोनों के लिए चरण 2। बेशक ऐसा कुछ बोझिल होगा, और सवाल का यह हिस्सा अकादमिक है।

(* क्योंकि प्रतिबिंब एक सुरक्षा प्रबंधक के साथ परेशानी दे सकता है)

(** कहते हैं अपने सीमित ज्ञान)

Answer 1

यह केवल सफाई से काम कर सकते हैं वस्तुओं में से एक अन्य द्वारा बनाई गई है। अभी तक यह पूरी तरह से आरंभ नहीं कर रहा है: उदाहरण के लिए आप कुछ इस तरह करने के लिए अपने User वर्ग बदल सकते हैं (जबकि Inventory वर्ग अपरिवर्तित रखते हुए):

class User { 
    private final Inventory inventory; 
    User() { 
     inventory = new Inventory(this); 
    } 
} 

आप Inventory निर्माता में User वस्तु तक पहुँचने तथापि, के बारे में सावधान रहने की जरूरत है । उदाहरण के लिए, इसका inventory फ़ील्ड अभी भी null होगा!

विज्ञापन अद्यतन: अब मैं सत्यापित किया है कि बाईटकोड-हेरफेर दृष्टिकोण काम नहीं करता। मैंने Jasmin का उपयोग करके इसे आजमाया है और यह हमेशा VerifyError से लोड करने में विफल रहा है।

इस मुद्दे में गहराई से वितरण, मुझे § 4.10.2.4 Instance Initialization Methods and Newly Created Objects मिला। यह खंड बताता है कि JVM कैसे सुनिश्चित करता है कि केवल प्रारंभिक ऑब्जेक्ट इंस्टेंस पास हो जाएं।

Answer 2

यदि आप किसी ऑब्जेक्ट को इंजेक्ट करने की आवश्यकता नहीं है तो आप इसे कर सकते हैं।

class User { 
    private final Inventory inventory; 
    User() { 
     inventory = new Inventory(this); 
    } 
} 

Answer 3

class User { 
    private final Inventory inventory; 
    User (/*whatever additional args are needed to construct the inventory*/) { 
     //populate user fields 
     inventory = new Inventory(this); 
    } 
} 

class Inventory { 
    private final User owner; 
    Inventory (User own) { 
     owner = own; 
    } 
} 

कि सबसे अच्छा मैं के बारे में सोच सकते हैं। शायद एक बेहतर पैटर्न है।

Answer 4

यह एक "समाधान" है, हालांकि final का नुकसान असुविधाजनक है।

class User { 
    Inventory inventory; 
    User() { } 
    // make sure this setter is only callable from where it should be, 
    // and is called only once at construction time 
    setInventory(inv) { 
     if (inventory != null) throw new IllegalStateException(); 
     inventory = inv; 
    } 
} 

class Inventory { 
    final User owner; 
    Inventory (User own) { 
     owner = own; 
    } 
} 

Answer 5

आप केवल JVM बाईटकोड में रुचि रखते हैं और विशेष रूप से जावा में कोडिंग, शायद स्काला या Clojure का उपयोग कर मदद कर सकता है के बारे में परवाह नहीं करते हैं। आपको किसी प्रकार की letrec मशीनरी की आवश्यकता होगी।

Answer 6

थोड़ा सा पैडेंटिक, लेकिन अगर आप थोड़ा संकेत नहीं देते हैं, तो यह एक दूसरे के अंदर बनाने के लिए सख्ती से जरूरी नहीं है। वे दोनों आंतरिक कक्षाएं हो सकती हैं।

public class BadlyNamedClass { 
    private final User owner; 
    private final Inventory inventory; 

    public BadlyNamedClass() { 
     this.owner = new User() { 
      ... has access to BadlyNamedClass.this.inventory; 
     }; 
     this.inventory = new Inventory() { 
      ... has access to BadlyNamedClass.this.owner; 
     }; 
    } 
    ... 
} 

या भी:

public class BadlyNamedClass { 
    private final User owner; 
    private final Inventory inventory; 

    public BadlyNamedClass() { 
     this.owner = new User(this); 
     this.inventory = new Inventory(this); 
    } 
    public User getOwner() { return owner; } 
    public Inventory getInventory() { return inventory; } 
    ... 
} 

Answer 7

बी: "उपयोगकर्ता द्वारा बनाई गई सूची हमारे पिछले आशा है।"
वाई: "नहीं, एक और है।"

यदि आप किसी तीसरे पक्ष के संदर्भों को सार करते हैं, तो आप उस संबंध में नियंत्रण कर सकते हैं।

उदाहरण के लिए।

public class User 
{ 
    private final String identifier; // uniquely identifies this User instance. 

    public User(final String myIdentifier) 
    { 
     identifier = myIdentifier; 

     InventoryReferencer.registerBlammoUser(identifier); // Register the user with the Inventory referencer. 
    } 

    public Inventory getInventory() 
    { 
     return InventoryReferencer.getInventoryForUser(identifier); 
    } 
} 

public interface Inventory // Bam! 
{ 
    ... nothing special. 
} 

// Assuming that the Inventory only makes sence in the context of a User (i.e. User must own Inventory). 
public class InventoryReferencer 
{ 
    private static final Map<String, Inventory> referenceMap = new HashMap<String, Inventory>(); 

    private InventoryReferencer() 
    { 
     throw ... some exception - helps limit instantiation. 
    } 

    public static void registerBlammoUser(final String identifier) 
    { 
     InventoryBlammo blammo = new InventoryBlammo(); 
     referenceMap.add(indentifier, blammo); 
    } 

    public static void registerKapowUser(final String identifier) 
    { 
     InventoryBlammo kapow = new InventoryKapow(); 
     referenceMap.add(indentifier, kapow); 
    } 

    public static Inentory getInfentoryForUser(final String identifier) 
    { 
     return referenceMap.get(identifier); 
    } 
} 

// Maybe package access constructors. 
public class InventoryBlammo implements Inventory 
{ 
    // a Blammo style inventory. 
} 

public class InventoryKapow implements Inventory 
{ 
    // a Kapow style inventory. 
}