The word "abstraction" could be used in two ways in OO:
- as an entity (to refer a class or an interface)
- as a principle
"The principle of Abstraction advocates the simplification of entities through reduction and generalization: reduction is by elimination of unnecessary details and generalization is by identification and specification of common and important characteristics."
you may take a look at enabling techniques defined for each fundamental object-oriented principle here; these enabling techniques may help you understand the principles easily.
Details change frequently.
Abstractions tend to change far less frequently.
With that being the case, the less your system has to know about itself and the specifics of it's implementation, the less dependant your implementation details will be on other implementation details - relying on abstractions instead.
This makes your code less coupled (a good thing) and less brittle. If you need to change an implementation detail without changing it's abstraction, then you can often do so without breaking anything. If your code is tightly coupled (because it knows too much about itself) then you'll likely end up performing shotgun-surgery because what should be a simple change has rippling effects throughout the rest of the code which has become dependant on that little detail which has changed.
You showed up just in time for the waffles! And this tiny ad:
Building a Better World in your Backyard by Paul Wheaton and Shawn Klassen-Koop