Date Abstraction
Hiding implementation is not just a matter of putting a layer of fucntions between the variables.Hiding implementation is about abstractions!A class does not simply push its varivables out through getters and setters.Rather it exposes abstract interfaces that allow its users to manipulate the essence of data, without having to know is implementation.
Data/Object Anti-Symmetry
Procedual code makes it hard to add new data structures because all the functions must change.OO code makes it hard to add new functions because all the classes must change.
In any complex system there are going to be times when we want to add new data types rather than new functions.For these cases objects and OO are most appropriate.On the ohter hand,there will also be times when we‘ll want to add new functions as opposed to data types.In that case procedual code and data structures will be more appropriate.
The Law of Demeter
There is a well-known heuristic called the Law of Demeter that says a module should not know about the innards of the objects it manipulates.As we saw in the last section,objects hide their data and expose operation.This means that an object should not expose its internal structure throught accessors because to do so is to expose,rather than to hide,its internal structure.
More precisely, the Law of Demeter says that a method f of a class C should only call the methods of these:
C
An object created by f
An object passed as an argument of f
An object held in an instance variable of C
The method should not invoke methods on objects that are returned by any of the allowed functions.In other words,talk to friends,not to strangers.
Train Wrecks
This kind of code is often called a train wreck because it looks like a bunch of coupled train cars.Chains of calls like this are generally considered to be sloppy style and should be avoided.
Hybrids
The confusion sometimes leads to unfortune hybrid structures that are half object and half data structure.They have functions that do significant things,and they also have either public variables or public accessors and mutators that, for all intends and purpose,make the private variables public,tempting other external functions to use those variables the way a procedural program would use a date structure.
Such hybrids male it hard to add new functions but also make it hard to add new data structures.They are the worst of both worlds.Avoid creating them.They are indicative of a muddled design whose authors are unsure of -or worse,ignorant of-whether they need protection from functions or types.
Hiding Structure
Data Transfer Objects
The quintessential form of a data structure is a class with public variables and no functions.This is sometimes called a data transfer object, or DTO.DTOs are very useful structures,especialy when communicating with databases or parsing messages from sockets,and so on.They often become the first in a serious of translation stages that covert raw data in a database into objects in the application code.Beans have private variables manipulated by getters and setters.The quasi-encapsulation of beans seems to make some OO purists feel better but usually provides no other benefit.
Active Record
Active Records are special forms of DTOs.They are data structures with public variables;but they typically have navigational methods like save and find.Typically these
Active Records are direct translations from database tables, or other data sources.
Unfortunately we often find that developers try to treat these data structures as though they were objects by putting business rule methods in them.This is awkward because it creates a hybrid between a date structure and an object.
The solution is to treat the Active Record as a data structure and to create separate objects that contain the business rules and that hide thier internal data.
Conclusion
Objects expose behavior and hide data.This makes it easy to add new kinds of objects without changing existing behaviors.It also makes it hard to add new behaviors to existing objects.Data structures expose data and habe no significant behavior.This makes it easy to add new behaviors t existing data structures but makes it hard to add new data structures to existing functions.