Law of Demeter
The Law of Demeter (aka Principle of Least Knowledge) is a nice little trick you can use when writing programs according to the principles of OOP.
What is it?
The law is simply this. In any piece of code, the code can only refer to:
- Methods of self / this
- Attributes of self / this
- Methods of attributes of self / this. (This is the only case of using two 'dot's.)
- Parameters to the method.
- Methods of those parameters.
- Stuff created as part of the method.
- Methods of stuff created.
Or, in simplest terms:
self.X self.X() self.X.Y() X X.Y()
self.X.Y self.X.Y().Z X.Y X.Y().Z Z = X.Y(); Z()
The following code is OK: (Python code below)
def foo(self, bar): self.foo() self.a self.a.foo() bar.foo() baz = Baz() baz.foo()
While the following code is not OK:
def foo(self, bar): self.foo().bar() self.foo().attr self.a.foo().attr self.a.foo().foo() bar.attr bar.foo().foo() bar.foo().attr baz = Baz() # this is actually OK baz.attr baz.foo().attr baz.foo().foo()
Why should you follow the Law of Demeter? Because it helps you write easier code.
Think of it this way. Any bit of code has to "know" all about its parameters and the object it is a method of. By "know", I mean that certain assumptions are made about what the object is and what attributes and methods it has.
By using the Law of Demeter, the "knowledge" of the code is dramatically reduced. This is because the code is written assuming that the object, the parameters, and the created objects are understood. And even then, only the methods of the parameters and created objects are assumed.
Now, I am a firm believer in Attribute-Method Equivalence.That is, simply, that there should be no difference between attributes and methods except that methods are attributes that are callable. So the way I look at the Law of Demeter is to count the number of dots and that's it.