Polymorphic and non Polymorphic

14y1.8kVisual Basic .NET

This example is given in the following website http://www.c-sharpcorner.com/Forums/Thread/156771/. It is said that "override is polymorphic but new is not".

When we use new keyword the output is:
/*
Student Megan has 15 credits
Student Luke has 15 credits
Student
*/

When we use override keyword the output is:
/*
Student Megan has 15 credits
Student Luke has 15 credits
Student Megan has 15 credits
*/

The word polymorphism means "many forms". Here new and override taking many forms. How can be said that override is polymorphic but new is not. Problem is highlighted.

using System;

class DemoStudents4
{
public static void Main()
{
Student payingStudent = new Student();
ScholarshipStudent freeStudent = new ScholarshipStudent();

payingStudent.SetName("Megan");
payingStudent.SetCredits(15);

freeStudent.SetName("Luke");
freeStudent.SetCredits(15);

object obj = payingStudent;

Console.WriteLine(payingStudent.ToString());
Console.WriteLine(freeStudent.ToString());
Console.WriteLine(obj.ToString());

Console.ReadKey();
}
}

class Student
{
private string name;
protected int credits;

public void SetName(string name)
{
this.name = name;
}
public void SetCredits(int creditHours)//SetCredits in the child class as well
{
credits = creditHours;
}
public new/override string ToString() //Tostring() overrides the Object class version.
{
string stuString = "Student " + name + " has " + credits + " credits";
return stuString;
}
}

class ScholarshipStudent : Student
{
new public void SetCredits(int creditHours)
{
credits = creditHours;
}
}

4 Replies

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

Vulpes14y ago
Accepted answer
The type of a variable is simply it's declared type:

Base b = new Derived();

The declared type of 'b' is Base.

The type of the object is the actual type of object assigned to the variable which, in the above example, is Derived.

However, if the line had been:

Base b = new Base();

then the type of the object would, of course, be Base.

This is important in polymorphism because it's the type of the object (not the variable) which determines which version of the method/property gets called.
14y ago
Thank you for your explanation.
14y ago
Although this looks a bit like polymorphism, technically it's not. The difference is that the type of the variable (not the type of the object which is assigned to it) determines which version of the method gets called. For example:

What is the difference between the type of the variable and the type of the object?
Vulpes14y ago
By default a derived class inherits all its base class's members, except its constructor(s) and destructor, if it has one.

In the case of methods and properties, the derived class inherits not just the member but the implementation itself.

However, if you declare the method or property to be virtual in the base class, then the derived class can provide its own implementation by overriding the base class member.

Moreover, if you have a variable of the base class type and invoke a virtual member using that variable, then it is the actual type of the object to which the variable refers which determines the version of the method or property to be called. For example:

class Base
{
public virtual void VirtualMethod()
{
// code
}
}

class Derived : Base
{
public override void VirtualMethod()
{
// different code
}
}

// ....

Base b = new Base();
b.VirtualMethod(); // calls Base class version
b = new Derived();
b.VirtualMethod(); // calls Derived class version
Derived d = new Derived();
d.VirtualMethod(); // calls Derived class version

This is what is known as polymorphism - the method/property has 'many forms' depending on the type of object on which its invoked.

However, C# also allows you to hide a base class property/method whether it's virtual or not:

class Base
{
public virtual void SomeMethod()
{
// code
}
}

class Derived : Base
{
new public void SomeMethod()
{
// different code
}
}

Although this looks a bit like polymorphism, technically it's not. The difference is that the type of the variable (not the type of the object which is assigned to it) determines which version of the method gets called. For example:

Base b = new Base();
b.SomeMethod(); // calls Base class version
b = new Derived();
b.SomeMethod(); // also calls Base class version
Derived d = new Derived();
d.SomeMethod(); // calls Derived class version