Difference between runtime and compile time polymorphism?

Polymorphism is defined as one interface to control access to a general class of actions. There are two types of polymorphism one is compile time polymorphism and the other is run time polymorphism. Compile time polymorphism is functions and operators overloading. Runtime time polymorphism is done using inheritance and virtual functions.

Polymorphism means that functions assume different forms at different times. In case of compile time it is called function overloading. For example, a program can consist of two functions where one can perform integer addition and other can perform addition of floating point numbers but the name of the functions can be same such as add. The function add() is said to be overloaded. Two or more functions can have same name but their parameter list should be different either in terms of parameters or their data types. The functions which differ only in their return types cannot be overloaded. The compiler will select the right function depending on the type of parameters passed. In cases of classes constructors could be overloaded as there can be both initialized and uninitialized objects. Here is a program which illustrates the working of compile time function overloading and constructor overloading.
eg.
namespace CommonClasses
{
    public interface IAnimal
    {
        string Name { get; }
        string Talk();
    }
}
 
<i>// Assembly: Animals</i>
using System;
using CommonClasses;
 
namespace Animals
{
    public abstract class AnimalBase
    {
        public string Name { get; private set; }
 
        protected AnimalBase(string name) {
            Name = name;
        }
    }
 
    public class Cat : AnimalBase, IAnimal
    {
        public Cat(string name) : base(name) {
        }
 
        public string Talk() {
            return "Meowww!";
        }
    }
 
    public class Dog : AnimalBase, IAnimal
    {
        public Dog(string name) : base(name) {            
        }
 
        public string Talk() {
            return "Arf! Arf!";
        }
    }
}
 
<i>// Assembly: Program</i>
<i>// References and Uses Assemblies: Common Classes, Animals</i>
using System;
using System.Collections.Generic;
using Animals;
using CommonClasses;
 
namespace Program
{
    public class TestAnimals
    {
        <i>// prints the following:</i>
        <i>//   Missy: Meowww!</i>
        <i>//   Mr. Bojangles: Meowww!</i>
        <i>//   Lassie: Arf! Arf!</i>
        <i>//</i>
        public static void Main(string[] args)
        {
            var animals = new List<IAnimal>() {
                new Cat("Missy"),
                new Cat("Mr. Bojangles"),
                new Dog("Lassie")
            };
 
            foreach (var animal in animals) {
                Console.WriteLine(animal.Name + ": " + animal.Talk());
            }
        }
    }
}

..............................................................................................................................................................

The term static polymorphism is associated with overloaded methods because it gives the impression that a single named method will accept a number of different argument types. The System.out.println() method is an example that may take String or Object references boolean and other primitive types as an argument. In fact each overloaded method is separate and the compiler can see the difference between them. In this case the argument types are fixed at compile time and are considered static. This has nothing to do with the Java keyword static. Dynamic polymorphism is where a class overrides a superclass method or implements an interface. For example any class may override the Object.toString() method and provide its own implementation and this is known at compile time. However for a simple Java program that instantiates a series of objects and calls their toString() method the compiler does not consider the object references differently. Any differences in the objects' toString() implementations are only seen at runtime so they are considered dynamic.


...............................................................................................................................................................

The term static polymorphism is associated with overloaded methods
because it gives the impression that a single named method will accept
a number of different argument types. The System.out.println() method
is an example that may take String or Object references, boolean and
other primitive types as an argument. In fact, each overloaded method
is separate and the compiler can see the difference between them. In
this case, the argument types are fixed at compile time and are
considered static. This has nothing to do with the Java keyword
static.
Dynamic polymorphism is where a class overrides a superclass method or
implements an interface. For example, any class may override the
Object.toString() method and provide its own implementation, and this
is known at compile time. However, for a simple Java program that
instantiates a series of objects and calls their toString() method,
the compiler does not consider the object references differently. Any
differences in the objects' toString() implementations are only seen
at runtime, so they are considered dynamic.



2 comments:

Lauraine said...

I have no words for this great post such a awe-some information i got gathered. Thanks to Author.
html5 video player| html5 player

shajil said...

hi friend your post good,but i cant understand what is the difference between the polymorphism. can you plz let me know with small example of this concept.thanks a lot ....

Post a Comment