I read that the following format comes under parametric polymorphism, but can we classify it in one, either runtime or compile time polymorphism?
public class Stack<T>
{ // items are of type T, which is known when we create the object
T[] items;
int count;
public void Push(T item) {...}
//type of method pop will be decided when we create the object
public T Pop()
{...}
}
It's a little of both. In order to use a generic class, you have to give it a type parameter at compile time, but the type parameter could be of an interface or base class, so the actual, concrete type of the objects used at runtime can vary.
For example, here I have a snippet of code with a Stack<T> field. I've chosen to use an interface as the type parameter. This utilizes parametric polymorphism at compile time. You must choose which type parameter your _stack field will use at compile time:
public interface IFoo { void Foo(); }
public Stack<IFoo> _stack = new Stack<IFoo>();
Now, when this snippet of code is actually run, I can use any object whose class implements IFoo, and that decision doesn't have to be made until run time:
public class Foo1 : IFoo { public void Foo() { Console.WriteLine("Foo1"); } }
public class Foo2 : IFoo { public void Foo() { Console.WriteLine("Foo2"); } }
public class Foo3 : IFoo { public void Foo() { Console.WriteLine("Foo2"); } }
_stack.Push(new Foo1());
_stack.Push(new Foo2());
_stack.Push(new Foo3());
This is an example of subtype polymorphism, which is utilized at run time.
