polymerphism

Debiprasad Biswal

10y1.5kC#

why function override has super class reference variable and sub class object ?

4 Replies

Know the answer? Post it — somebody with the same question will find it here.

Mukesh Kumar10y ago
Hi,
Method Overloading means creating multiple methods in the class having same name but different signatures (Parameters). It permits a class, struct, or interface to declare multiple methods with the same name with unique signatures.

Compiler automatically calls required method to check number of parameters and their type which are passed into that method.
using System;
namespace DemoCsharp
{
class Program
{
public int Add(int num1, int num2)
{
return (num1 + num2);
}
public int Add(int num1, int num2, int num3)
{
return (num1 + num2 + num3);
}
public float Add(float num1, float num2)
{
return (num1 + num2);
}
public string Add(string value1, string value2)
{
return (value1 + " " + value2);
}
static void Main(string[] args)
{
Program objProgram = new Program();
Console.WriteLine("Add with two int parameter :" + objProgram.Add(3, 2));
Console.WriteLine("Add with three int parameter :" + objProgram.Add(3, 2, 8));
Console.WriteLine("Add with two float parameter :" + objProgram.Add(3 f, 22 f));
Console.WriteLine("Add with two string parameter :" + objProgram.Add("hello", "world"));
Console.ReadLine();
}
}
}
Method Overriding means having two methods with same name and same signature [parameters], one should be in base class and other method should be in derived class [child class]. You can override the functionality of base class to create a same name method with same signature in derived class. You can achieve method overriding using inheritance. Virtual and Override keywords are used to achieve method overriding.
using System;
namespace DemoCsharp
{
class BaseClass
{
public virtual int Add(int num1, int num2)
{
return (num1 + num2);
}
}
class ChildClass: BaseClass
{
public override int Add(int num1, int num2)
{
if (num1 <= 0 || num2 <= 0)
{
Console.WriteLine("Values could not be less than zero or equals to zero");
Console.WriteLine("Enter First value : ");
num1 = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Enter First value : ");
num2 = Convert.ToInt32(Console.ReadLine());
}
return (num1 + num2);
}
}
class Program
{
static void Main(string[] args)
{
BaseClass baseClassObj;
baseClassObj = new BaseClass();
Console.WriteLine("Base class method Add :" + baseClassObj.Add(-3, 8));
baseClassObj = new ChildClass();
Console.WriteLine("Child class method Add :" + baseClassObj.Add(-2, 2));
Console.ReadLine();
}
}
}
Hope this will help you.
thanks
0
Rajeesh Menoth10y ago
Hi,

Refer this article :

http://www.c-sharpcorner.com/UploadFile/8a67c0/method-overloading-and-method-overriding-in-C-Sharp/
0
Francis Susaimichael10y ago
why function override has super class reference variable and sub class object ?

Since overriding comes into picture, when "inheritance" comes. Also, at that time alone, it will be resolved at run time. So that only, you can achieve "Run time" polymorphism.

class BC
{
public virtual void Display()
{
System.Console.WriteLine("BC::Display");
}
}
class DC : BC
{
public override void Display()
{
System.Console.WriteLine("DC::Display");
}
}
class Program
{
static void Main(string[] args)
{
BC b;
b = new BC();
// Achieve run time polymorphism
b = new DC();
b.Display();
// Give compile time polymorphism
DC n = new DC();
n.Display();
}
}

Hope this helps!
0
Raja T10y ago
Hi,
There's a difference between new and virtual/override.
You can imagine, that a class, when instantiated, is nothing more than a table of pointers, pointing to the actual implementation of its methods. The following image should visualize this pretty well:
Now there are different ways, a method can be defined. Each behaves different when it is used with inheritance. The standard way always works like the image above illustrates. If you want to change this behavior, you can attach different keywords to your method.
1. Abstract classes
The first one is abstract. abstract methods simply point to nowhere:
If your class contains abstract members, it also needs to be marked as abstract, otherwise the compiler will not compile your application. You cannot create instances of abstract classes, but you can inherit from them and create instances of your inherited classes and access them using the base class definition. In your example this would look like:
```
public abstract class Person { public abstract void ShowInfo(); }  public class Teacher : Person { public override void ShowInfo() { Console.WriteLine("I am a teacher!"); } }  public class Student : Person { public override void ShowInfo() { Console.WriteLine("I am a student!"); } }
```
If called, the behavior of ShowInfo varies, based on the implementation:
```
Person person = new Teacher(); person.ShowInfo(); // Shows 'I am a teacher!'  person = new Student(); person.ShowInfo(); // Shows 'I am a student!'
```
Both, Students and Teachers are Persons, but they behave different when they are asked to prompt information about themselves. However, the way to ask them to prompt their information, is the same: Using the Person class interface.
So what happens behind the scenes, when you inherit from Person? When implementing ShowInfo, the pointer is not pointing to nowhere any longer, it now points to the actual implementation! When creating a Student instance, it points to Students ShowInfo:
2. Virtual methods
The second way is to use virtual methods. The behavior is the same, except you are providing anoptional default implementation in your base class. Classes with virtual members can be instanciated, however inherited classes can provide different implementations. Here's what your code should actually look like to work:
```
public class Person { public virtual void ShowInfo() { Console.WriteLine("I am a person!"); } }  public class Teacher : Person { public override void ShowInfo() { Console.WriteLine("I am a teacher!"); } }
```
The key difference is, that the base member Person.ShowInfo isn't pointing to nowhere any longer. This is also the reason, why you can create instances of Person (and thus it does not need to be marked as abstract any longer):
You should notice, that this doesn't look different from the first image for now. This is because the virtual method is pointing to an implementation "the standard way". Using virtual, you can tell Persons, that they can (not must) provide a different implementation for ShowInfo. If you provide a different implementation (using override), like I did for the Teacher above, the image would look the same as for abstract. Imagine, we did not provide a custom implementation for Students:
```
public class Student : Person { }
```
The code would be called like this:
```
Person person = new Teacher(); person.ShowInfo(); // Shows 'I am a teacher!'  person = new Student(); person.ShowInfo(); // Shows 'I am a person!'
```
And the image for Student would look like this:
3. The magic `new` keyword aka "Shadowing"
new is more a hack around this. You can provide methods in generalized classes, that have the same names as methods in the base class/interface. Both point to their own, custom implementation:
The implementation looks like the one, you provided. The behavior differs, based on the way you access the method:
```
Teacher teacher = new Teacher(); Person person = (Person)teacher;  teacher.ShowInfo(); // Prints 'I am a teacher!' person.ShowInfo(); // Prints 'I am a person!'
```
This behavior can be wanted, but in your case it is misleading.
I hope this makes things clearer to understand for you!
More details checkout below links

http://stackoverflow.com/questions/17717570/why-does-calling-a-method-in-my-derived-class-call-the-base-class-method

http://www.c-sharpcorner.com/Blogs/9394/polymorphism-with-example.aspx

http://www.onlinebuff.com/article_oops-principle-polymorphism-in-c-with-an-example_17.html
0

polymerphism

1. Abstract classes

2. Virtual methods

3. The magic `new` keyword aka "Shadowing"