When using composition when to favour wrapper methods?

Question

When using composition, when should we favour wrapper methods? Let's say we have the classic car example.

public class Car {
   private Battery battery;
   
   //wrapper method
   public void load(float p) {
       this.battery.load(p)
   }
}


public class Battery {
   public void load(float percentage) {
   }
}

The alternative would be to make a getter method that returns the battery so other code would load the battery like this car.getBattery().load(...), but then: should we return the reference or a clone? And what would be more future-proof?

Answer 1

Unless you have a really good reason to do otherwise, take the first approach. It's known as the "tell, don't ask" principle.

There are some underlying principles in object-oriented code:

• You use method calls to tell an object what you want it to do.
• Objects are responsible for managing their own data.
• Callers shouldn't need to know about the internal data structures of an object they are calling.

If you allow a caller to fetch a reference to an internal data item, then:

• The object no longer has control of the data it's supposed to be managing.
• The caller now knows about the internals of the object it's fetching data from.

For long-term maintainability, the second approach is a mess, as it tightly couples the design of the object to its caller.

Answer 2

The principle of the least knowledge (law of Demeter) should be your friend:

An object a can request a service (call a method) of an object instance b, but object a should not "reach through" object b to access yet another object, c, to request its services. Doing so would mean that object a implicitly requires greater knowledge of object b's internal structure.

a being the caller, b the car, and c the battery, you should stick to your design and let b operate its components. This has the advantage that you could change the internals (e.g. add more batteries) without consequences to the externals.

If instead, you would return the battery, the caller would have to to know that there is one and only one battery and how to operate it. And if you'd add more batteries to the internals, you'd have to change the calling code to cope with the new design.