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.