|A black box is an engineering term that works like this. First we drop something in to a black box. Then, we wait while our thing is "magically transformed" inside the black box. Finally, we receive a new transformed thing back from the black box. The beauty of a black box is that all we need to know is how to drop something into the black box and what to expect on the other side. We do not need to understand the magic inside.|
Well, that means that nobody but the object itself needs to know anything about how its properties and methods are defined and implemented.
Are the list of items stored in an array or a vector? How is sorting handled, with a quick sort or a bubble sort? How is a selection marked and how do you handle multiple selections?
Encapsulation means that the answers to all these questions are private, known only by the object itself.
What is the benefit of this?
Well, the benefit is that if I want to use a Select Box, I do not need to deal with all of the complex code that handles all of the functionality of a select box. Instead, I just put the self-contained select box object in my application and use it.
This is an incredibly useful concept because it means that it is far easier to modify and understand code because you only need to deal with small pieces of code at any one time. As a developer, I do not need to deal with the intricacies of select box functionality, I just use the thing!
It is also a good metaphor for the real world, that can be thought of as being made up of encapsulated objects.
Consider the computer you are using to read this. Do you know how the CPU works? Most likely you don't. But that is fine. It works regardless. And the fact that you don't have to spend time learning electrical engineering means that you are free to spend your time building things "using" the CPU. Application Programming Interface (API) So what do we know about an object and what do we need to do to use an object?
Well, the only thing the programmer needs to know is how to get information from the object when the information is needed or how to tell the object to perform some action when some action is required.
For example, consider the case in which a web browser wants to know which item has currently been selected in the FORM Select Box because the user has clicked the submit button and it needs to formulate the HTTP request.
In this case, the web browser software will simply ask the select box object which item is currently selected and the select box object will answer.
So how does the web browser software ask the select box object for the currently selected item?
Typically, objects provide an Application Programer's Interface (API) that allows other objects (like web browser software or a larger application) to get information or to ask the object to perform an action.
An API is a set of publicly available methods that yield or effect certain pieces of information about the state of an object.
In the case above, the select box object will have an API method that will return the selected item.
Generically, the interaction between the web browser software and the object might work like this...
|Web Browser Software:||Hey Select Box object, the user just pushed the submit button and I need to put together a URL encoded string for the HTTP request. What item is currently selected?|
|Select Box Object:||"Apples" is currently selected.|
|Web browser happily goes off and formulates the HTTP request without ever needing to know how the select box object performs its magic.|
Why should we go through an accessor method instead of simply accessing the object's property itself?
Well, "encapsulating" objects and providing API methods to the outside world allows us to hide the object's properties and methods that is necessary for black box abstraction.
In this way we assure that regardless of how we change the select box object in the future, so long as the API stays the same all objects and routines that utilize the select box object will not break. Nobody cares about the code inside an object, they only care about the object's API.
This makes writing and modifying code much, much easier and goes a long way towards solving the spaghettification dilemma.