polymerphism

Question

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

Mukesh Kumar · Answer

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 { 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

Rajeesh Menoth · Answer

Hi Refer this article : http://www.c-sharpcorner.com/UploadFile/8a67c0/method-overloading-and-method-overriding-in-C-Sharp/

Francis · Answer

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!

Raja T · Answer

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 Student s and Teacher s are Person s 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 Student s ShowInfo : 2. Virtual methods The second way is to use virtual methods. The behavior is the same except you are providing an optional 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 Student s: 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