Wednesday, 25 November 2015

Abstraction

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)
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 :
Namespace AbstractionExample
       Public MustInherit Class Shape
               Private _area As Single
               Private _perimeter As Single

               Public Property Area() As Single
                       Get
                               Return _area
                       End Get
                       Set
                               _area = value
                       End Set
               End Property
               Public Property Perimeter() As Single
                       Get
                               Return _perimeter
                       End Get
                       Set
                               _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.