Inheritance with Shadowing and Overriding

Question

4.00/5 (1 vote)

See more:

Hello Friends,

I know there are many information available on internet for Inheritance, Overriding and Shadowing. The difference between them etc. etc.

There are some real life scenario with example also explained very well. After reading some of those i can say :-
Shadowing is giving a new life to existing items.
Overriding is changing existing life.

To understand it clearly i wrote a simple test program.

C#

public class cls1
    {
        public void TestFoo() { Console.Write("Base Class TestFoo. \n"); }
        public virtual void fun1()
        {
            Console.Write("cls1 fun1 \n");
        }
        public void foo() { Console.Write("Base class function.\n"); }
    }

    public class cls2 : cls1
    {
        public void TestFoo() { Console.Write("Child Class TestFoo. \n"); }
        public override void fun1()
        {
            Console.Write("cls2 fun1 \n");
        }
        public new void foo() { Console.Write("Child class function.\n"); }
    }

   static void Main(string[] args)
        {
            // Normal

            cls1 objTestFoo = new cls1();
            objTestFoo.TestFoo(); // "Base class TestFoo"

            cls1 objTestFoo1 = new cls2();
            objTestFoo1.TestFoo(); // "Base class TestFoo" ???? Why it is calling Base class function
 
            cls2 objTestFoo2 = new cls2();
            objTestFoo2.TestFoo(); // "Child class TestFoo"           

            // overide

            cls1 obj1 = new cls1();
            obj1.fun1(); // "cls1 fun1"

            cls1 obj2 = new cls2();
            obj2.fun1(); // "cls2 fun1" ????? why it is calling child class fun1

            cls2 obj3 = new cls2();
            obj3.fun1(); // "cls2 fun1"
            
            // new 

            cls1 obj1_new = new cls1();
            obj1_new.foo(); // "Base Class function"

            cls1 obj2_new = new cls2(); ???? why it is calling base class function
            obj2_new.foo(); // "Base Class function"

            cls2 obj3_new = new cls2();
            obj3_new.foo(); // "Child Class function"
}

What i am not able to understand is why it is calling different functions when we give reference of base class in to child class object.

Posted 9-Mar-14 5:30am

girishmeena

Updated 9-Mar-14 7:56am

v4

Add a Solution

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

OriginalGriff · Accepted Answer · 2014-03-09T06:00:00

It's just for illustration.
It doesn't really work as an example is you have

C#

BaseClass bc = new BaseClass();
bc.MyMethod();
DerivedClass dc = new DerivedClass();
dc.MyMethod();

Giving:

BaseClass MyMethod called
DerivedClass MyMethod called

Because you could get that result without deriving any class at all!
If you write the above as

C#

BaseClass example = new BaseClass();
example.MyMethod();
example = new DerivedClass();
example.MyMethod();

And it gives the same result (which is does) that that shows that inheritance works (a derived class instance reference can be assigned to a base class variable) and that the system sorts out the overriding for you by calling the appropriate method for the actual instance without referring to the variable type.
When you do the same with new methods it does look at the variable type:

C#

Base bc = new Base();
Derived dc = new Derived();
bc.MyMethod();
dc.MyMethod();
bc = dc;
bc.MyMethod();

And you get:

Base: MyMethod called
Derived: MyMethod called
Base: MyMethod called

which shows it.