I have several classes that compose other class instances as properties. For example, ClassA contains ClassB, ClassC, and ClassD; ClassD then contains several more objects, including ClassD9. When I call a method on ClassD9, it sometimes needs a property owned by ClassB, which is effectively its sibling several levels up the object tree. Right now I pass the entire ClassA instance down manually, like `myClassAObject.itsClassDObject.theClassD9method(myClassAObject)`, and then ClassD9 reaches back through `parent.itsClassBObject.theProperty`. This works, but it feels tightly coupled and inelegant. What design or dependency-passing approach would be cleaner?
4 Answers
The deeper issue may be the object design rather than the syntax. If many nested objects need to reach across the hierarchy, consider moving the coordination into ClassA or a separate service/module. The lower-level classes can expose focused operations, while the coordinator calls them in the right order. Another option is to pass a narrow context object containing only operations such as `lookup`, `move`, or `getProperty`, rather than passing the full parent.
Having a child store a reference to its parent can be reasonable when the objects are genuinely parts of one larger aggregate. For example, ClassA can construct ClassB and ClassC with `this`, and those classes can use `this.parent` when they need to coordinate. It’s a straightforward solution, although it still creates strong coupling, so it’s best when the object hierarchy is stable and intentional.
For complicated shared state, split the public controller from the internal state access. A top-level controller can own the data and expose a small internal API to its child objects. The children receive that API directly, so they can access what they need without knowing the entire class tree. If the classes mostly hold data and have little behavior, plain objects plus functions that accept the relevant data may be simpler still.
Usually, pass the specific dependency the method needs rather than the entire top-level object. If ClassD9 only needs one value or operation from ClassB, give it that value or a small interface during construction or when calling the method. That keeps ClassD9 from knowing about ClassA’s complete structure and makes it easier to test.
I tried that approach in one class and found `this.parent.someThing` fairly convenient. I’d still avoid exposing the whole parent if the child only needs one small part of it.