Law of Demeter also known as principle of least knowledge is a coding principle, which says that a module should not know about the inner details of the objects it manipulates. If a code depends upon internal details of a particular object, there is good chance that it will break as soon as internal of that object changes. Since Encapsulation is all about hiding internal details of object and exposing only operations, it also assert Law of Demeter. One mistake many Java programmer makes it exposing internal detail of object using getter methods and this is where principle of least knowledge alerts you. I first come to know about this principle, while reading one of the must read programming book, Robert C. Martin’s Clean code. Apart from many good thing the book teaches you, “principle of least knowledge” is one principle, which I still remember. Like many bad things, you will tempt to violate Law of Demeter, because of beautiful chaining of methods written in fluent style. On surface it looks pretty good, but as soon as you think about principle of least knowledge, you start seeing the real picture. In this article, we will see formal definition of Law of Demeter and explore code snippet which violates this principle.
Law of Demeter
According to Law of Demeter, a method M of object O should only call following types of methods :
- Methods of Object O itself
- Methods of Object passed as an argument
- Method of object, which is held in instance variable
- Any Object which is created locally in method M
More importantly method should not invoke methods on objects that are returned by any subsequent method calls specified above and as Clean Code says “talk to friends, not to strangers”. Apart from knowing object oriented programming basic concepts e.g. Abstraction, Polymorphism, Inheritance and SOLID design principle, it’s also worth knowing useful principle like this, which has found it’s way via experience. In following example, we will see how a method can violate above rules to violate Law of Delimiter.
public class LawOfDelimterDemo {
/**
* This method shows two violations of "Law of Delimiter" or "Principle of least knowledge".
*/
public void process(Order o) {
// as per rule 1, this method invocation is fine, because o is a argument of process() method
Message msg = o.getMessage();
// this method call is a violation, as we are using msg, which we got from Order.
// We should ask order to normalize message, e.g. "o.normalizeMessage();"
msg.normalize();
// this is also a violation, instead using temporary variable it uses method chain.
o.getMessage().normalize();
// this is OK, a constructor call, not a method call.
Instrument symbol = new Instrument();
// as per rule 4, this method call is OK, because instance of Instrument is created locally.
symbol.populate();
}
}
You can see that when we get internal of Order class and call a method on that object, we violate Law of delimiter, because now this method knows about Message class. On the other hand calling method on Order object is fine because its passed to the method as parameter. This image nicely explains what you need to do to follow Law of Demeter.
Let’s see another example of code, which violates the Law of Demeter and how does it affect code quality.
public class XMLUtils {
public Country getFirstBookCategoryFromXML(XMLMessage xml) {
return xml.getXML().getBooks().getBookArrary(0).getBookHeader().getBookCategory();
}
}This code is now dependent upon lot of classes e.g.
XMLMessage
XML
Book
BookHeader
BookCategory
Which means this function knows about XMLMessage, XML, Book, BookHeader and BookCategory. It knows that XML has list of
Book, which in-turn has BookHeader and which internally has BookCategory, that’s a lot of information. If any of the intermediate class or accessor method in this chained method call changes, then this code will break. This code is highly coupled and brittle. It’s much better to put the responsibility of finding internal data into the object, which owns it. If we look closely, we should only call getXML() method because its method from XMLMessage class, which is passed to method as argument. Instead of putting all this code in XMLUtils, should be putting on BookUtils or something similar, which can still follow Law of Demeter and can return the required information.
| Reference: | Law of Demeter in Java – Principle of least Knowledge – Real life Example from our JCG partner Javin Paul at the Javarevisited blog. |
you probably have a spell checker with that “law of delimiter”.