Question

I am learning OOP and have a question about what is exactly happening with the code below.

I have the classic Dog Animal example going. Dog inherits Animal.

public class Animal
{
    public string Name { get; set; }

    public virtual string Speak()
    {
        return "Animal Speak";
    }

    public string Hungry()
    {
        return this.Speak();
    }
}


public class Dog : Animal
{
    public override string Speak()
    {
        return "Dog Speak";
    }

    public string Fetch()
    {
        return "Fetch";
    }
}

Both questions are based on this assignment: Animal a = new Dog();

1. What is actually happening when I declare an Animal and set it to a Dog reference. Is there a specific term for this?
2. When I call a.Hungry(), the output is “Dog Speak.” If the output is “Dog Speak”, why can I not call a.Fetch()? What is the term for what’s happening here?

Any help and further reading on the particular topic would be greatly appreciated.

Answer 1

1. This is an “upcast”. In C# there is an implicit conversion from any type to any of it’s base types, so you don’t need to do anything to treat a Dog as if it were an Animal. (Thanks to Matt Burland for reminding me that this is the appropriate term.)
2. Because the type of the variable is Animal, and as such you can only access members that the compiler knows an Animal can access, i.e. Speak and Hungry. It doesn’t know that the Animal is a Dog, so it can’t call Fetch. The variable would need to be of type Dog for you to be able to call Fetch on it.