In the previous article What's really differs an Interface from a class?: Part I I tried to distinguish the interface concept from the class concept by studying and parsing each one from a pure nature point of view and I tried to put the focus on first concept as it doesn't already clear for some people. In this article, I will respond to the second question posed in the previous one.
Compare the Interface function to the class function:
Generally classes including abstract classes serve as base model to other classes those inherit them and extend them through overriding members. Especially, abstract classes are perfect tools to generate new derived types, at the other hand, interfaces serve as bridge between different types even they are heterogeneous and I mean that they don't belong to the same family each others. Although the class serves to create new derived types, interfaces provide more functions. To better understand the diver services provided by both classes and interfaces let take a look at this example. Imagine an abstract class Hominid that serves as a base model to derived classes or types. This is a hominid representation.
class Homini
{
public abstract string Category{get; set;}
public abstract uint Age{get; set;}
public abstract uint Height{get; set;}
public abstract uint Weight{get; set;}
public abstract void Behaviour ();
}
Given that those derived classes are Human, Chimpanzee and orangutan. We can implement them as follow
The human class:
|
public class Human:Hominid
{
public Human()
: base()
{ }
private string _Category;
public override string Category
{
get
{
return _Category;
}
set
{
_Category = value;
}
}
private uint _Age;
public override uint Age
{
get
{
return _Age;
}
set
{
_Age = value;
}
}
private uint _Height;
public override uint Height
{
get
{
return _Height;
}
set
{
_Height = value;
}
}
private uint _Weight;
public override uint Weight
{
get
{
return _Weight;
}
set
{
_Weight = value;
}
}
public override void Behaviour()
{
Console.WriteLine("I'm a human");
Console.ReadKey(true);
Console.Beep();
}
}
|
The Chimpanzee class:
|
public class Chimpanzee:Hominid
{
public Chimpanzee()
: base()
{ }
private string _Category;
public override string Category
{
get
{
return _Category;
}
set
{
_Category = value;
}
}
private uint _Age;
public override uint Age
{
get
{
return _Age;
}
set
{
_Age = value;
}
}
private uint _Height;
public override uint Height
{
get
{
return _Height;
}
set
{
_Height = value;
}
}
private uint _Weight;
public override uint Weight
{
get
{
return _Weight;
}
set
{
_Weight = value;
}
}
public override void Behaviour()
{
Console.WriteLine("I'm a Chimpanzee");
Console.ReadKey(true);
Console.Beep();
}
}
|
The Orangutan class:
|
class Ourangoutan
{
public Ourangoutan()
: base()
{ }
private string _Category;
public override string Category
{
get
{
return _Category;
}
set
{
_Category = value;
}
}
private uint _Age;
public override uint Age
{
get
{
return _Age;
}
set
{
_Age = value;
}
}
private uint _Height;
public override uint Height
{
get
{
return _Height;
}
set
{
_Height = value;
}
}
private uint _Weight;
public override uint Weight
{
get
{
return _Weight;
}
set
{
_Weight = value;
}
}
public override void Behaviour()
{
Console.WriteLine("I'm a Ourangoutan");
Console.ReadKey(true);
Console.Beep();
}
}
|
So the principal role of an abstract class is to specialize each of those derived types, I mean Human, Chimpanzee and the Orangutan. The relationship can be presented by the following diagram:
![]()
Figure 6
This is the principal function of the abstract class.
Now, Say that we have other creatures that share almost the same characteristics as the Hominid. Antelopes are best example in such case. Well, Gazelles and Gnus could be excellent Antelopes example. But the problem is although Antelopes share same characteristics as Hominids, they don't belong to them. Even in a C++ environment where the multi inheritance is allowed, we can't resolve such problem and improve this relationship between Hominid and Antelope.
Interfaces come and put an end to this problem, by extracting the common characteristics of the both creatures' categories and serve as bridge between them. In fact, interfaces have more functions than this but let begin with this first utility. Ok, the question now is how to accomplish the task within Visual Studio when you have already developed the hominids family?
The problem is solved by Visual studio as it extracts the right interface automatically for you via refactoring the code. You just follow the procedure as follow. First, browse to the Hominid class then select the Extract Interface menu item.
![]()
Figure 7
The following window appears and invites you to select the common members. Those members will be integrated within the interface core.
![]()
Figure 8
Press "Select all" as you will extract all the abstract class members then press OK. The interface will be generated automatically for you.
using System;
namespace myProject
{
interface IHominid
{
uint Age { get; set; }
void Behaviour();
string Category { get; set; }
uint Height { get; set; }
uint Weight { get; set; }
}
}
Notice that the Hominid class implements now the new IHominid interface.
using System;
using System.Collections.Generic;
using System.Text;
namespace myProject
{
class Hominid : myProject.IHominid
{
public abstract string Category{get; set;}
public abstract uint Age{get; set;}
public abstract uint Height{get; set;}
public abstract uint Weight{get; set;}
public abstract void Behaviour ();
}
}
Now, design the Gazelle and the Gnus classes so that they implement the new interface each.
The visual studio also provides us a short hand to rapidly develop classes that implement interface. In fact when you type this code:
class Gazelle:IHominid
{
}
The first letter of the interface is underlined as follow:
![]()
Figure 9
When you move the mouse over this line a drop down list will appears as bellow:
![]()
Figure 10
In fact, you are invited to implement all interface members either explicitly or implicitly. If classes implement members with same name or signature as within the interface then use explicit implementation to avoid conflicts between members whose have the same name and don't mark the interface members with access keys such as public, otherwise they will be shadowed by the class members. Else you can just implement your interface members implicitly. The following graph
![]()
Figure 11
As you see, all types share the same members, and this can not be possible without the interface concept that serves as a bridge within a heterogeneous environment. You shouldn't miss the Part III-What's really differs an Interface from a class? Within witch I will expose more utility provided by interfaces.