How to override the method –
If we want to override a method first
under the parent class the method should be declared using virtual modifier,
now the child class gets the permission to override the method which can be
overridden by the child class using override modifier, but overriding the
method is only optional for the child class.
eg – LoadParent
public virtual void test1(int x)
|
LoadChild : LoadParent
public override void test1(int x)
|
Overriding is an option which allows to change
the behavior of the parent class method under child class according to its
requirement. To change the behavior parent class is giving the permission by
declaring the method as virtual.
- To test this goes into the Class LoadParent
and rewrite the Test method as following –:
public virtual void test1(int x)
{
Console.WriteLine("method test1");
}
|
Now run the child class
and check the result which also prove overriding is only optional.
- Add a new method under the class LoadChild as
following:
public override void test1(int x)
{
Console.WriteLine("Method test 3");
}
|
Now again run the child class and check the
difference in result , where in the place of virtual method the overridden
method gets executed, Because object of the child class gives First preference
to Local methods .
After the child class is overriding a virtual
method of its parent if required the child class has a chance to invoke virtual
methods of Parent Class also, which can be done in two different ways –
- By creating the object of parent class child class can invoke Parent class’s virtual method.
{
LoadParent p = new LoadParent();
LoadChild c = new LoadChild();
p.test1(10); // Invoke
parent class method
c.test1(10); //Invoke
child class method
Console.ReadLine();
}
|
Note – Earlier we have discussed references of
parent class that are created using object of child class cannot invoke child
class members but we have an assumption in overriding i.e. these references can
invoke the overridden methods under child class because overriding is performed
with the permission of parent.
To test this rewrites the code under main method
of class LoadChild as following –
{
LoadChild c = new LoadChild();
LoadParent p =
c;
p.test1(10); // Invokes
child class method only
c.test1(10); //Invokes
child class method
Console.ReadLine();
}
|
2. using ‘base ‘keyword also from child class from child class
we can invoke virtual methods of parent but using of “base and this key words” from a static block
is invalid
To test the process add new method under child
class as following –
public void Ptest(int x)
{
base.test1(x);
}
|
Now in the main method of Child class rewrite
the code as following –
{
LoadChild c = new LoadChild();
c.Ptest(10); // Invokes
Parent class method
c.test1(10); //Invokes
child class method
Console.ReadLine();
}
|
q. How to re-define a parent class method under
child class –
Ans – A parent class method can be re- defined
under its child class using two different approaches
- Method overriding
- Method Hiding
1.) In the first case parent class gives
the permission for child class to re-define its method by declaring it as
virtual, now he child class can re-define the method using override modifier.
2.) In the second case
parent class doesn’t give any permission to re-define its method to the child
class, but still the child class can re-define it without any permission of its
parent.
LoadParent
|
public void show()
public virtual void test
(int x)
|
LoadChild : LoadParent
|
public new void show() // method hiding
public override void test (int x) // method overriding
|
To test this add new method under the class load
child as following-
public new void show ()
{
Console.WriteLine("Method show 2");
}
|
All the rules we have discussed in case of
overriding applies to method hiding also accept reference of parent class
created from object of Child can invoke overridden methods of child but not the
methods which are re-implemented using method hiding approach.
To check this rewrite the code under main method
of class load child as following-
{
LoadChild c = new LoadChild();
LoadParent p =
c;
p.show(); // Invokes
parent method because this is method hiding
c.test(10); //Invokes
child method because this is method overriding
Console.ReadLine();
}
|
Polymorphism is of two types :
- Static or compile time polymorphism.
- Dynamic or run time polymorphism.
In the first case the
object of class recognizes which Polymorphic method it has to call at the time
of compilation of the program only, which is possible in overloading.
In the second case the
object of a class recognizes which Polymorphic method it has to call at run
time of while executing the program, this happen in case of method overriding
and method hiding.
0 Comments