|
Shadowing
|
Overriding
|
| When
base class and derived class have a method of same name but they are
independent copies, then it is termed as shadowing. |
When
derived class extends and overrides a method of base class, then it
is termed as overriding. |
Shadowing
is achieved by using the new keyword in the derived class method signature.
Here is an example:
class baseClass {
public void sample(){ }
}
class derivedClass : baseClass {
public new void sample() { }
}
|
Overriding
is achieved by using the override keyword in the derived class method
signature. Here is an example:
class baseClass {
public virtual void sample(){ }
}
class derivedClass : baseClass {
public override void sample() { }
}
|
Shadowing
doesn't bother if the base class method is marked as virtual or not.
In the above example, the method sample is not marked as virtual but
it will work. Even if you mark the base class method as virtual and
define your derived class method using new modifier, it will not throw
any error. Consider the following example:
namespace Application1 {
public class baseClass {
public virtual void sample() { }
}
public class derivedClass:baseClass {
public new void sample() { }
}
}
This example is legal.
|
For
a method to be overridden, base class method has to be marked as abstract
or virtual or it should be an overridden method of a higher level
base class in the hierarchy. Consider the following example:
namespace Application1 {
class baseClass {
public void sample() { }
}
class derivedClass:baseClass {
public override void sample() { }
}
}
During execution of this code, you will get the following error:
'Application1.derivedClass.sample()': cannot override inherited member
'Application1.baseClass.sample()'because it is not marked virtual,
abstract, or override
|
If the
base class method is defined as abstract, then the method has to be
overridden in the derived class. Defining the same method with the
same signature using new modifier will not work. Consider the following
example:
namespace Application1{
abstract class baseClass {
public abstract void sample();
}
class derivedClass : baseClass {
public new void sample() { }
}
}
During execution, this code will end up in the following error:
'Application1.derivedClass' does not implement inherited abstract
member 'Application1.baseClass.sample()'
|
If there
is any abstract method in the base class, then it has to overridden
in the derived class using override keyword. Consider the following
example:
namespace Application1{
abstract class baseClass {
public abstract void sample();
}
class derivedClass : baseClass {
public override void sample() { }
}
}
This is legal and it will work.
|
The
method sharing the same name in base class and derived class can have
a different method signature since they are actually two different
methods. Consider the following example:
namespace Application1 {
class baseClass {
public void sample(){ };
}
class derivedClass:baseClass {
public void sample(int data) { }
}
}
This example is perfectly legal.
|
The
method sharing the same name in base class and derived class are actually
the same method. Hence they should have the same signature. Consider
the following example:
namespace Application1 {
class baseClass {
public virtual void sample(){ };
}
class derivedClass:baseClass {
public override void
sample(int data) { }
}
}
This is not permissible and you will get the following error:
'Application1.derivedClass.sample(int)': no suitable method found
to override
|
| When
you don't explicitly specify new or override keywords in your derived
class method which shares the same name as your base class method,
then it will implicitly have new modifier. |
A method
will not be overridden implicitly. You have to explicitly override
a method using override keyword.
|
