As I was reading about coupling and cohesion, I also came across the Principle of Least Knowledge, which just so happened to be on our list of topics in the syllabus.
The Principle of Least Knowledge (or Law of Demeter) was first discussed in 1987 at Northeastern University. It states that an object should never now the internal details of other objects, which makes sense given the name. It is used to promote loose coupling in software designs.
The article also gives an example using 3 classes – A, B, and C. Each class has objects objA, objB, and objC. objA is dependent on objB, which in turn composes objC. In this scenerio, objA can invoke methods and properties of objB but not objC. Say C has a method M. If you make a objC called O, the Principle of Least Knowledge says O can access
- The same object, i.e., the object “O” itself
- Objects that have been passed as an argument to the method “M”
- Local objects, i.e., objects that have been created inside the method “M”
- Global objects that are accessible by the object “O”
- Direct component objects of the object “O”
A code example is also given to illustrate the concept.
public class LawOfDemeterExample
//This is an instance in the class scope
//and hence this instance can be accessed by any members of this class
AnotherClass instance = new AnotherClass();
public void SampleMethodFollowingLoD(Test obj)
DoNothing(); //This is a valid call as you are calling a method of the same class
object data = obj.GetData(); //This is also valid since you are calling a method
//on an instance that has been passed as a parameter
int result = instance.GetResult(); //This is also a valid call as you are calling
//a method on an instance locally created
private void DoNothing()
// Write some code here
After, an second example is given to illustrate what not to do.
var data = new A().GetObjectB().GetObjectC().GetData();\
In this example the client depends on all three classes A, B, and C. If any of the three change you will run into issues.
This principle will definitely be important as I continue my career in software development. As the ode I write gets more complex, I have to be wary of violating principles like this to maintain low coupling. The author also mentions testability being improved with this principle and the loosely coupled code it encourages. Next semester I am taking the software testing course; right now I have next to no knowledge about software testing. I only know how to just test units made for me in java. Hopefully I will see how loosely coupled code compared to tightly coupled code in testability.