C# is an Object-oriented programming language. C# comes with simplicity, expressiveness and great performance to meet the programmer productivity.
Introduction
So far, we have seen
conversion keywords in
C#. Now, let's study polymorphism, static and dynamic polymorphism in C# in this chapter.
Objective
The main objective of this article is to learn about method overloading and method overriding in polymorphism in
C# programming.
Polymorphism
Polymorphism simply means 'many forms'. After encapsulation and inheritance, polymorphism plays a major role in object-oriented programming.
In other words, polymorphism means the states or behaviors of an object such as emotions of a person.
There are two types of polymorphism. They are,
Above diagram shows the brief architecture of polymorphism in object-oriented programming.
Static Polymorphism
In static polymorphism, the decision and response to a method is determined at the compile time. Therefore, it is also known as compile-time polymorphism. Static polymorphism involves static binding or early binding.
As the name indicates that early binding links a method with an object at compile time. Hence, calling of method should be done in compile time only.
Method overloading and operator overloading are the examples of static polymorphism.
Method Overloading:
Method overloading or function overloading is the concept of having more than one methods in a class with the same name and different parameters.
Compiler automatically calls required method by checking number of parameters and their type which are passed into that method.
If the credentials (number of parameters and type) doesn't matched by any method signatures, then it will give compile time error.
Example,
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Man
{
class MyClass
{
public void MyMethod(int x, int y) // MyMethod with int parameters
{
Console.WriteLine("Integers = " + x + y);
}
public void MyMethod(char x, char y) // MyMethod with char parameters
{
Console.WriteLine("Characters = " + x + y);
}
public void MyMethod(string x, string y) // MyMethod with string parameters
{
Console.WriteLine("Strings = " + x + y);
}
}
class Program
{
static void Main()
{
MyClass var = new MyClass();
var.MyMethod(2, 3); // This automatically calls int's method
var.MyMethod('a', 'b'); // This calls char's method
var.MyMethod("Method", "Overloading"); // This automatically calls string's method
}
}
}In the above example code, we have three functions with the same name (
MyMethod) but different parameters i.e.
int parameters for the first one,
chars for the second and
strings for the third one.
In the Main method, if we instantiate integer values, it automatically goes and calls a method which has int parameters.
And if we give characters, it automatically invokes the method which has char parameters.
Similarly if we instantiate string items, it calls the particular method (MyMethod with string parameters) in that class.
Output of this program will prints the following lines in your console,
Dynamic Polymorphism
In dynamic polymorphism, the decision and response to a method is determined at the run time. Therefore, it is also known as run-time polymorphism. dynamic polymorphism involves late binding.
late binding or dynamic binding is a process of linking method to an object during run time (run-time binding).
Method overriding is an example of dynamic polymorphism.
Method Overriding:
Method overriding or function overriding is the concept of having duplicated methods in base and derived classes with same name as well as same parameters.
- Only abstract and virtual methods can be overridden.
- We cannot declare an abstract method without an abstract class.
- And we cannot an instance of an abstract class.
- For more information, read abstract and virtual modifiers.
Because of run-time binding, we can point to any derived class from the base class object at the run time.
Compiler doesn't participate in here to check whether the method is available or not for overriding functionality. Hence, it doesn't throws any compile time errors at in this case.
All the decisions are made at the runtime and we will get runtime error if there is no method to be called.
Example,
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Man
{
class BaseClass
{
public virtual void MyMethod() // Virtual method; Gives runtime error if you remove this method
{
Console.WriteLine("This is the Base Class");
}
}
class DerivedClass : BaseClass
{
public override void MyMethod() // Overriding virtual method
{
Console.WriteLine("This is the Derived Class");
}
}
class Program
{
static void Main()
{
BaseClass msg = new BaseClass();
msg.MyMethod(); // This will call the BaseClass method
msg = new DerivedClass();
msg.MyMethod(); // This will call the DerivedClass method
}
}
}In the above example, we have a
virtual method
MyMethod() in the
BaseClass which is overridden in the
DerivedClass.
In the Main method, we created an object which is initially pointed to BaseClass method. Hence it calls that method at the runtime.
Again we pointed the same object to the DerivedClass method in which it calls that method at the runtime.
Output of the above code will prints the following lines in your console,
Now in the above code, remove the MyMethod() in the BaseClass and run again.
This will throw a runtime error like below,
Conclusion
In this article, we have studied about polymorphism and types of polymorphism with examples. Hope you understand.
Thanks for reading.
Regards,
Krishna.