Wednesday, 25 November 2015


Abstraction :
·         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)
Only members within the same type.  (default for type members)
Only derived types or members of the same type.
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.
Any code. No inheritance, external type, or external assembly restrictions.

Code Example :
Namespace AbstractionExample
       Public MustInherit Class Shape
               Private _area As Single
               Private _perimeter As Single

               Public Property Area() As Single
                               Return _area
                       End Get
                               _area = value
                       End Set
               End Property
               Public Property Perimeter() As Single
                               Return _perimeter
                       End Get
                               _perimeter = value
                       End Set
               End Property
               Public MustOverride Sub CalculateArea()
               Public MustOverride Sub CalculatePerimeter()
       End Class
End Namespace

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.