- 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 abstract class Shape
        {
            private float _area;
            private float _perimeter;
            public float Area
            {
                get
                {
                    return _area;
                }
                set
                {
                    _area = value;
                }
            }
            public float Perimeter
            {
                get
                {
                    return _perimeter;
                }
                set
                {
                    _perimeter = value;
                }
            }
            public abstract void CalculateArea();
            public abstract void CalculatePerimeter();
        }
}
        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.
Comments
Post a Comment