30/11/2010 Untitled Document

Source : Mindcracker Network (www.c-sharpcorner.com) P rint

OOPS Concepts and .NET Part 2: Inheritance, Abstraction, &

Polymorphism

Summary

The following article is the second of a three-part article series that presents definitions and
samples for different Object-Oriented Programming (OOP) concepts and its implementation in .NET.
The first part examined the concepts of classes, objects, and structures. This part examines the
c onc epts of inheritance, abstraction, and polymorphism. The third and last part will examine the
c onc epts of interface, multiple interface inheritance, collections, and overloading.

Introduction

In Part 1 of Object-Oriented Programming Concepts and .NET, I defined the concepts of class,
object, and struc ture. In addition to defining the concepts, I explained real world samples and
presented sample code in C# and VB.NET to create classes and structs. The first artic le also
explains objects as independent building blocks.

In Part 2 of Object-Oriented Programming Concepts and .NET, I will explain the c onc epts of
inheritanc e, abstrac tion, and polymorphism. I will also present a Unified Model Language (UML) class
diagram to represent an object model that will help as a visual aid to explain some c onc epts. The
purpose of this article is to explain a series of relationships between objects.

Inheritance

In the real world there are many objects that c an be specialized. In OOP, a parent class c an inherit
its behavior and state to c hildren c lasses. This c onc ept was developed to manage generalization
and specialization in OOP and is represented by a is-a relationship.

The following OO terms are c ommonly used names given to parent and c hild c lasses in OOP:

Superclass: Parent c lass.

Subclass: Child class.
Base class: Parent class.
Derived class: Child class

The most common real world sample to explain inheritance is the geometric shapes object model.
Squares, c ircles, triangles, rec tangles, pentagons, hexagons, and octagons are geometric shapes.
The following figure shows a sample set of geometric figures:

1/7
30/11/2010 Untitled Document

Figure 1. Geometric shapes.

The c onc ept of generalization in OOP means that an objec t encapsulates common state an behavior
for a c ategory of objec ts. The general object in this sample is the geometric shape. Most geometric
shapes have area, perimeter, and color. The concept of specialization in OOP means that an object
c an inherit the common state and behavior of a generic object; however, each object needs to
define its own special and particular state an behavior. In Figure 1, eac h shape has its own c olor.
Each shape has also partic ular formulas to c alculate its area and perimeter.

Inheritance makes code elegant and less repetitive. If we know that all shapes have color, should
we program a c olor attribute for each shape? The answer is no! Would it be a better idea to create
a shape c lass that has a color attribute and to make all the specialized shapes to inherit the color
attribute? The answer is yes!

An object model for this sample c ould have a shape parent c lass and a derived class for each
specific shape. The following UML class diagram shows the set of classes needed to model the
geometric shapes sample. Observe the field, properties, and methods for each class:

2/7
30/11/2010 Untitled Document

Figure 2. The Shape class is the parent class. Square, Rectangle, and Circle are derived c lasses that
inherit from Shape. The triangle-c onnector in the diagram represents an is-a relationship.

The .NET framework has many base classes. Everything is derived from System.Object. You can
c reate almost anything you imagine using the built-in functionality provided in the .NET Framework
Class Library.

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

c lass child: parent

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

Class c hild
Inherits parent
End Class

Multiple inheritance

Multiple inheritance is the possibility that a child c lass c an have multiple parents. Human beings have
always two parents, so a c hild will have charac teristics from both parents.
3/7
30/11/2010 Untitled Document

In OOP, multiple inheritance might become diffic ult to handle bec ause it allows ambiguity for the
c ompiler. There are programming languages suc h as C++ that allow multiple inheritanc e; however,
other programming languages suc h as Java and the .NET Framework languages do not allow multiple
inheritanc e. Multiple inheritance can be emulated in .NET using Multiple Interface Inheritanc e, which
I will explain in Part 3 of this series.

Sealed class

A sealed class is a class that does not allow inheritance. Some object model designs need to allow
the c reation of new instanc es but not inheritance, if this is the case, the class should be declared
as sealed.

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

sealed class Shape

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

NonInheritable Class Shape

Abstraction

Abstraction is "the proc ess of identifying common patterns that have systematic variations; an
abstrac tion represents the c ommon pattern and provides a means for specifying whic h variation to
use" (Richard Gabriel).

An abstract c lass is a parent c lass that allows inheritance but can never be instantiated. Abstract
c lasses contain one or more abstract methods that do not have implementation. Abstract c lasses
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 ac count. People own savings acc ounts,
c hec king accounts, c redit ac counts, investment ac counts, but not generic bank ac counts. In this
c ase, a bank ac count c an be an abstrac t class and all the other specialized bank ac counts inherit
from bank acc ount.

To create an abstract c lass in C#, the c lass dec laration should be done as:

abstrac t class Shape

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

MustInherit Class Shape

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

/// C#
using System;
namespace DotNetTreats.OOSE.OOPSamples
{
public abstract c lass Shape
{
private float _area;
private System.Drawing.Color _color;
private float _perimeter;
public float Area

4/7
30/11/2010 Untitled Document
{
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 c lasses are derived or
inherited from the same parent class, each derived c lass will have its own behavior. Polymorphism is
a concept linked to inheritance and assures that derived c lasses 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 c alculated; however, eac h shape c alculates its area in a spec ialized way.
Declaring a member as abstract allows polymorphism. The Shape class defines the CalculateArea()
and CalculatePerimeter() methods as abstrac t, this allows each derived c lass to override the
implementation of the parent's methods.

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

/// C#
using System;
namespace DotNetTreats.OOSE.OOPSamples
5/7
30/11/2010 Untitled Document
{
c lass Rec tangle : 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 Rec tangle's methods.

Virtual keyword

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

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

public virtual void Draw()

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

Public Overridable Func tion Draw()

6/7
30/11/2010 Untitled Document
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 abstrac t members allow derived c lasses to override them.

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

public override void CalculateArea()

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

Public Overrides Func tion CalculateArea()

Conclusion

Inheritance allows developers to manage a generalization and specialization relationship between

objects. OOP c onc epts suc h as abstrac tion and polymorphism help to define better object models
where object hierarchies are designed with reusability in mind. In this article, I examined the
c onc ept of inheritanc e, abstraction, and polymorphism. The third and last part of this series will
examine the concepts of interface, multiple interface inheritanc e, 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 Mic rosoft Visual Basic .NET and Microsoft Visual C# .NET
Step by Step, Mic rosoft Press, 2002.

Thank you for using Mindcracker Network

7/7