In static polymorphism response to a function is decided at compile time.
In Dynamic polymorphism response to a function is decided at run time.
1)Static polymorphism is achieved by method overloading where as run
time polymorphism( or dynamic polymorphism) is achieved by method
overriding.
2)static polymorphism uses the concept of compile time binding(or early
binding) where as dynamic polymorphism uses the concept of runtime
binding (or late binding).
3)Dynamic polymorphism is faster than static polymorphism.
4)To implement static polymorphism inheritance is not necessary where as
to implement dynamic polymorphism inheritance is necessary.
5)Generally when a programmer want to extend existing feature in a
software,method overloading(load + extra load(more lines of code)) is
used,and a programmer uses method overriding when he wants to provide a
different implementation.
Understanding Static & Dynamic Polymorphism with Examples.
What is polymorphism? Poly means many. So how can we
take this definition in .NET context. Well we can apply this to class’s
ability to share the same methods (actions) but implement them
differently.
Suppose we have a method in a class to add numbers,
public class calculation
{
public int add(int x, int y)
{
return x+y;
}
}
So to perform addition of three numbers, we need similar add method but with different parameter
public class calculation
{
public int add(int x, int y)
{
return x+y;
}
public int add(int x, int y,int z)
{
return x+y+z;
}
}
So we can that class is sharing the same methods (actions) but implement them differently.
Now this is an example when we are sharing method name and
implementing them differently, let’s take a scenario where
implementation is in some derived class.
For instance, say we create a class called Shape and this class has a method called .Area () which calculates area. Then we create two subclasses, using inheritance, of this Shape class. One called Square, the other called Circle. Now obviously a square and circle are two entirely different shapes, yet both classes have the .Area() method. When the Square.Area() method is called it will calculate area of a square. When the Circle.Area() method is called, it will calculate area of a circle. So both classes can use the same methods but implement them differently.
Now let’s dive little deeper and understand what we discussed above in more technical terms.
Types of Polymorphism
1) Static or Compile time Polymorphism
Which method is to be called is decided at compile-time only. Method
Overloading is an example of this. Method overloading is a concept where
we use the same method name many times in the same class, but different
parameters. Depending on the parameters we pass, it is decided at
compile-time only. The same method name with the same parameters is an
error and it is a case of duplication of methods which c# does not
permit. In Static Polymorphism decision is taken at compile time.
public Class StaticDemo
{
public void display(int x)
{
Console.WriteLine(“Area of a Square:”+x*x);
}
public void display(int x, int y)
{
Console.WriteLine(“Area of a Square:”+x*y);
}
public static void main(String args[])
{
StaticDemo spd=new StaticDemo();
Spd.display(5);
Spd.display(10,3);
}
}
2) Dynamic or Runtime Polymorphism.
Run time Polymorphism also known as method overriding. In this
Mechanism by which a call to an overridden function is resolved at a
Run-Time (not at Compile-time) if a base Class contains a method that is
overridden. Method overriding means having two or more methods with the
same name, same signature but with different implementation. In this
process, an overridden method is called through the reference variable
of a superclass, the determination of the method to be called is based
on the object being referred to by reference variable.
Class BaseClass
{
Public void show ()
{
Console.WriteLine(“From base class show method”);
}
}
Public Class DynamicDemo : BaseClass
{
Public void show()
{
Console.WriteLine(“From Derived Class show method”);
}
Public static void main(String args[])
{
DynamicDemo dpd=new DynamicDemo ();
Dpd.show();
}
}
Here memory allocation will be at the run time for that particular method.
What is Virtual Function: They implement the concept of polymorphism are the same as in C#, except that you use the override keyword with the virtual function implementation in the child class. The parent class uses the same virtual keyword. Every class that overrides the virtual method will use the override keyword.
Why to use them:
1) It is not compulsory to mark the derived/child class function
with Override KeyWord while base/parent class contains a virtual method
2) Virtual methods allow subclasses to provide their own implementation of that method using the override keyword
3) Virtual methods can’t be declared as private.
4) You are not required to declare a method as virtual. But, if
you don’t, and you derive from the class, and your derived class has a
method by the same name and signature, you’ll get a warning that you are
hiding a parent’s method
5) A virtual property or method has an implementation in the base class, and can be overriden in the derived classes.
6) We will get a warning if we won’t use Virtual/New keyword.
7) Instead of Virtual we can use New Keyword
class A
{
public void M()
{
Console.WriteLine(“A.M() being called”);
}
public virtual void N()
{
Console.WriteLine(“A.N() being called”);
}
}
class B : A
{
public new void M()
{
Console.WriteLine(“B.M() being called”);
}
public override void N()
{
Console.WriteLine(“B.N() being called”);
}
}
say
A a = new B();
a.M();
a.N();
The results would be
A.M() being called
B.N() being called
Override Keyword: method overriding is 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.
class Shape
{
public virtual void Draw()
{
Console.WriteLine(“Shape.Draw”) ;
}
}
class Rectangle : Shape
{
public override void Draw()
{
Console.WriteLine(“Rectangle.Draw”);
}
}
