Abstraction with Example

• Abstraction refers to the act of representing essential features without including the background details or explanations.
• Abstraction defines way to abstract or hide your data and members from outside world.
• Classes use the concept of abstraction and are defined as a list of abstract attributes.
• Simply speaking Abstraction is hiding the complexities of your class or struct or in a generic term Type from outer world.
• This is achieved by means of access specifiers.

Access Modifier	Description (who can access)
Private	Only members within the same type.  (default for type members)
Protected	Only derived types or members of the same type.
Internal	Only code within the same assembly. Can also be code external to object as long as it is in the same assembly.  (default for types)
Protected internal	Either code from derived type or code in the same assembly. Combination of protected OR internal.
Public	Any code. No inheritance, external type, or external assembly restrictions.

Code Example :




Public abstract class Shape
{
     Private float _area;
     Public Float Area
     {
          Get{return _area;}
          Set{_area=value;}
     }
     Public abstract void CalculateArea();
 } 
     Class Rect:Shape
     {
           Private float _height;
           Private float _width;
           Public Rect(float height, float width)
           {
                   _height = height;
                   _width = width;
           }
           Public Float Height
           {
                 Get{return _height}
                 Set{_height=value;}
           }
           Public Float Width
           {
                  Get{return _width}
                  Set{_width=value;}
           }
           Public override void CalculateArea()
           {
                  This.Area=_height*_width;
      }

Advantages of abstraction are the hiding of implementation details, component reuse, extensibility, and testability. When we hide implementation details, we reveal a cleaner, more comprehensible and usable interface to our users. We are separating our interface from our implementation, and this makes component reuse more practical. Many, if not all of the object-oriented concepts we have discussed throughout this document play a role in the abstraction principle. Working together, their end goal is the same, to produce software that is flexible, testable, maintainable, and extensible.