基类=新派生类。 这是如何运作的？

Question

Say I have a base class called Enemy and a derived class called Ogre.

What is the difference between creating an instance these two ways:

Enemy newOgre = new Ogre();

Ogre newOgre = new Ogre();

Answer 1

Actually, the piece of code that is creating the instance is only new Ogre() . What is in the left side of the equal sign has nothing to do with creating the instance.

The first statement is simply assigning the created instance to a variable of type Enemy . The second one is assigning it to a variable of type Ogre .

So you have two variables of different types pointing to objects of the same type, ie Ogre .

The variable (what is on the left side of the equal sign), only determines what you can access from the object. For example, if the Ogre class has a method that is not inherited from Enemy , then using the Enemy variable, you will not be able to access it.

Please note that the variable does not effect how the object behave. For example, if Ogre overrides a method defined in Enemy that does something different. Calling this method on an instance of Ogre using a variable of type Enemy would cause the overridden method in Ogre to be invoked, not the one in Enemy ,

For example, consider these classes:

public class Enemy
{
    public virtual void Test()
    {
        Console.WriteLine("enemy");
    }
}

public class Ogre: Enemy
{
    public override void Test()
    {
        Console.WriteLine("ogre");
    }
}

Now if you do this:

Orge enemy = new Orge();
enemy.Test();

The console would print "ogre".

And if you do this:

Enemy enemy = new Ogre();
enemy.Test();

The console would still print "orge".

Answer 2

In addition to Yacoub's answer, in this case, Enemy would not contain the properties, and methods that Ogre has.

public class Enemy
{
    public int Property1 { get; set; }
    public int Property2 { get; set; }
}

public class Ogre : Enemy
{
    public int Property3 { get; set; }
}

Let's say you inherit Enemy in your Ogre class. This mean that your Ogre will effectively contain 3 properties: 1,2 and 3.

In your example you're assigning an Ogre to an Enemy type. The Enemy type doesn't contain a "Property3" and therefor you won't be able to work with the extended class " Ogre " in an Enemy cast object.

//This will work
Ogre newOgre = new Ogre();
int newInt = newOgre.Property3;

//This wont.
Enemy newOgre = new Ogre();
int newInt = newOgre.Property3;

Answer 3

One declares a variable of type Enemy and references a new Ogre object. The other declares a variable of type Ogre and references a new Ogre object.

Some differences (not an exhaustive list):

• You can't call non-inherited methods of Ogre on the variable of type Enemy .
• Any virtual methods of Enemy that are overridden in Ogre will use Ogre's implementation when called on either variable.

Answer 4

Here

Enemy newOgre = new Ogre();

you can't call method using newOgre that was later added to the class Ogre for example and was not in the base class, whereas using the other variable you can call those methods.

Answer 5

Assume your Enemy class looks like this:

public class Enemy
{
    public void Attack() { }
    public void Move() { }
}

and your Ogre class like this:

public class Ogre : Enemy
{
    public void OgreSmash() { }
}

With the Enemy variable you would only have access to Attack() and Move() but not to the OgreSmash() with the Ogre variable you will have access to the methods of the base and derived class.