I've been reading up on this "Law of Demeter" thing, and it (and pure "wrapper" classes in general) seem to generally be anti patterns. Consider an implementation class:
class Foo {
void doSomething() { /* whatever */ }
}
Now consider two different implementations of another class:
class Bar1 {
private static Foo _foo = new Foo();
public static Foo getFoo() { return _foo; }
}
class Bar2 {
private static Foo _foo = new Foo();
public static void doSomething() { _foo.doSomething(); }
}
And the ways to call said methods:
callingMethod() {
Bar1.getFoo().doSomething(); // Version 1
Bar2.doSomething(); // Version 2
}
At first blush, version 1 seems a bit simpler, and follows the "rule of Demeter", hide Foo's implementation, etc, etc. But this ties any changes in Foo to Bar. For example, if a parameter is added to doSomething, then we have:
class Foo {
void doSomething(int x) { /* whatever */ }
}
class Bar1 {
private static Foo _foo = new Foo();
public static Foo getFoo() { return _foo; }
}
class Bar2 {
private static Foo _foo = new Foo();
public static void doSomething(int x) { _foo.doSomething(x); }
}
callingMethod() {
Bar1.getFoo().doSomething(5); // Version 1
Bar2.doSomething(5); // Version 2
}
In both versions, Foo and callingMethod need to be changed, but in Version 2, Bar also needs to be changed. Can someone explain the advantage of having a wrapper/facade (with the exception of adapters or wrapping an external API or exposing an internal one).
