OOPS Concepts And .NET - Part Two - Inheritance, Abstraction And Polymorphism

To create a sealed class in C#, the class declaration should be done as:

sealedclassShape

To create a sealed class in VB.NET, the class declaration should be done as:

NonInheritable ClassShape

Abstraction

Abstraction is "the process of identifying common patterns that have systematic variations; an abstraction represents the common pattern and provides a means for specifying which variation to use" (Richard Gabriel).

An abstract class is a parent class that allows inheritance but can never be instantiated. Abstract classes contain one or more abstract methods that do not have implementation. Abstract classes allow specialization of inherited classes.

Figure 2 shows a Shape class, which is an abstract class. In the real world, you never calculate the area or perimeter of a generic shape, you must know what kind of geometric shape you have because each shape (eg. square, circle, rectangle, etc.) has its own area and perimeter formulas. The parent class shape forces all derived classes to define the behavior for CalculateArea() and CalculatePerimeter(). Another great example is a bank account. People own savings accounts, checking accounts, credit accounts, investment accounts, but not generic bank accounts. In this case, a bank account can be an abstract class and all the other specialized bank accounts inherit from bank account.

To create an abstract class in C#, the class declaration should be done as:

abstractclassShape

To create an abstract class in VB.NET, the class declaration should be done as:

MustInheritClassShape

To following code shows a sample implementation of an abstract class:

Code

using System;  
namespace DotNetTreats.OOSE.OOPSamples  
{  
    public abstract class Shape  
    {  
        private float _area;  
        private System.Drawing.Color _color;  
        private float _perimeter;  
        public float Area  
        {  
            get  
            {  
                return _area;  
            }  
            set  
            {  
                _area = value;  
            }  
        }  
        public System.Drawing.Color Color  
        {  
            get  
            {  
                return _color;  
            }  
            set  
            {  
                _color = value;  
            }  
        }  
        public float Perimeter  
        {  
            get  
            {  
                return _perimeter;  
            }  
            set  
            {  
                _perimeter = value;  
            }  
        }  
        public abstract void CalculateArea();  
        public abstract void CalculatePerimeter();  
    }  
}

Listing 1: The Shape abstract class in C#

Polymorphism

Polymorphism allows objects to be represented in multiple forms. Even though classes are derived or inherited from the same parent class, each derived class will have its own behavior. Polymorphism is a concept linked to inheritance and assures that derived classes have the same functions even though each derived class performs different operations.

Figure 2 shows a Rectangle, a Circle, and Square. All of them are shapes and as shapes their area and perimeter can be calculated; however, each shape calculates its area in a specialized way. Declaring a member as abstract allows polymorphism. The Shape class defines the CalculateArea() and CalculatePerimeter() methods as abstract, this allows each derived class to override the implementation of the parent's methods.

To following sample code shows an implementation of a derived class (rectangle). The specific CalculateArea() and CalculatePerimeter() methods for the rectangle class illustrate polymorphism:

Code

using System;  
namespace DotNetTreats.OOSE.OOPSamples  
{  
    class Rectangle: Shape  
    {  
        private float _height;  
        private float _width;  
        public rectangle(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;  
        }  
        public override void CalculatePerimeter()  
        {  
            this.Perimeter = (_height * 2) + (_width * 2);  
        }  
    }  
}

Listing 2: Polymorphism represented in the Rectangle's methods

Virtual keyword

The virtual keyword allows polymorphism too. A virtual property or method has an implementation in the base class, and can be overriden in the derived classes.

To create a virtual member in C#, use the virtual keyword:

publicvirtualvoidDraw()

To create a virtual member in VB.NET, use the Overridable keyword:

PublicOverridableFunctionDraw()

Override keyword

Overriding is the action of modifying or replacing the implementation of the parent class with a new one. Parent classes with virtual or abstract members allow derived classes to override them.

To override a member in C#, use the override keyword:

publicoverridevoidCalculateArea()

To override a member in VB.NET, use the Overrides keyword:

PublicOverridesFunctionCalculateArea()

Conclusion

Inheritance allows developers to manage a generalization and specialization relationship between objects. OOP concepts such as abstraction and polymorphism help to define better object models where object hierarchies are designed with reusability in mind. In this article, I examined the concept of inheritance, abstraction, and polymorphism. The third and last part of this series will examine the concepts of interface, multiple interface inheritance, collections, and overloading.

Note The sample source code* for this article works only in Visual Studio 2005.

Reference

• Matt Weisfeld, The Object-Oriented Thought Process, SAMS, 2000.
• Robin A. Reynolds-Haertle, OOP with Microsoft Visual Basic .NET and Microsoft Visual C# .NET Step by Step, Microsoft Press, 2002.