Interfaces Should Reveal Intention
Kristen Nygaard, father of object oriented programming and the Simula programming language focused in his lectures on how to use objects to model the behavior of the real world and on how objects interacted to get a piece of work done. His favorite example was Cafe Objecta, where waiter objects served the appetites of hungry customer objects by allocating seating at table objects, providing menu objects and receiving order objects.
In this type of model we will find a restaurant object with a public interface methods such as
availableTables(numberOfSeats,timePoint), waiter objects with methods such as
provideMenu<customer,tableNumber), object interfaces that reveal each object's intent and responsibility in terms of the domain at hand.
So, where are the setters and getters so often found dominating our object models? They are not here as they do not add value to the behavioral intention and expression of object responsibility.
Some might then argue that we need setters to support dependency injection a.k.a. inversion of control design principle. Dependency injection is a good thing as it provide reduced coupling and simplified unit testing as an object can be tested using a mock-up of a dependency. At the code level this mean that code such as
Table table = new TableImpl(..); can be replaced with
Table table; and then initialized from the outside at runtime.
The answer to that is that you do not need setters for that. Either you use the constructor or, even better, create an interface in an appropriate package called
ExternalInjections with methods prefixed with
initializeAttributeName(AttributeType). Again the intention of the interface has been made public and clear. An interface designed to support the use of a specific design principle or the intent of frameworks such as Spring.
So what about the getters? I think personally you are better of just referring to the actual attribute, using methods such as
timePoint(). Methods that return attributes are by definition functions and read better if they are direct:
item.price() reads better than
The conclusion on this is that setters and getters are alien constructs that do not reveal the intention of a behavior-centric interfaces reviling the objects intent and responsibility. Therefore you should avoid using them, there are better alternatives.
By Einar Landre
This work is licensed under a Creative Commons Attribution 3
Back to 97 Things Every Programmer Should Know home page