2

I am new the realm of Object Orientation and programming. There are some things I am still trying to understand.

For instance, I have the following code:

 public abstract class ParentA
    {
        public virtual void MethodA()
        {
            Console.WriteLine("Doing somethin...");
        }
    }
    public class DerivedClassA : ParentA
    {
        public override void MethodA()
        {
            Console.WriteLine("Doing something from derived...");
        }
    }

Now, I see some code where the class is instatiated like this:

ParentA p = new DerivedClassA();
            p.MethodA();

Why not just instatiate the actually class you want to use and use it's members?

 DerivedClassA d = new DerivedClassA();
            d.MethodA();

I see this used a lot interfaces as well where is written like this:

public interface Animal
    {
        void Bark();
    }
    public class Dog : Animal
    {
        public void Bark()
        {
            Console.WriteLine("bark");
        }
    }

and then used in this manner:

Animal a = new Dog();
            a.Bark();

Why not just do this??:

Dog d = new Dog();
            d.Bark();

When does it matter?

Thanks for the help

:)

Improve this question
3
  • 4
    Interfaces should start with I. Commented Dec 24, 2010 at 3:13
  • 3
    @SLaKs that is highly debatable now days. Prefixing interface names with I is historical baggage from the days of COM. Check out the discussion in the C# annotated reference. Commented Dec 24, 2010 at 3:21
  • 1
    Rodrick: I find it useful to be able to tell the difference between List and IList at a glance. Commented Dec 24, 2010 at 3:31

5 Answers 5

Reset to default
12

You're right; that does look odd, doesn't it?

The code:

Animal animal = new Dog();

is reasonably rare; normally if you knew you were making a Dog then you'd type the variable as Dog. What is more common is:

Animal animal = petStore.ObtainInexpensivePet();

where you don't know exactly what is going to come back; maybe a kitten, maybe an iguana, but you know it will at least be an Animal. It's the pet store that is creating the dog object, not you.

Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

In this case, would it be safe to say that ObtainInexpensivePet() is a method that returns an Animal type...like a factory creating a type of Animal I would like based on some user or programmable input? I am understanding the method returning the type of Animal, I just see many people doing the Animal animal = new Dog() scenario
@NewGuy1667: Exactly. Now, under what situations do you see someone assigning a derived type to a variable of base type? Is it 'real world' code or are you seeing this in pegagogic code? My guess would be that you're seeing this a lot in code which is intended to illustrate how virtual methods work: that is, based on the type of the object, not the type of the variable. Pedagogic code is often unrealistic.
I am seeing mostly in online articles (blogs, wiki etc). But there are many instances where I see it used.
I disagree that Animal animal = new Dog(); is reasonably rare, even for short-lived locals. It strongly suggests to the reader that we are going to henceforth "view" that dog simply as an animal. Now if there was some ((Dog)animal) going on later, that would be pretty weird. But IEnumerable<int> nums = new[]{3, 4, 5}; is perfectly sensible; it can clarify that we don't intend to mutate the array or access elements by index. Thoughts?
5

This technique can be used to make sure that the code is not coupled to a specific implementation.

If this particular derived class has additional methods (eg, List<T>), and you want to ensure that your code will work with other implementations that don't have these extra methods, declaring the variable as the base type will ensure that you don't call the methods.

Improve this answer

2 Comments

I dont quite understand this comment. Can you explain a bit? Thanks
@NewGuy1667: Using the List<T> example, you may have a List<T> now, but your algorithm only requires being able to add items. You could type the argument/variable as ICollection<T>. Doing so would prevent you from calling List specific methods such as AddRange which may not be available on other types (say ObservableCollection<T>) you may later want to pass into the algorithm.
1

The purpose behind calling a.Bark vs. d.Bark is so that you don't need to know the actual type of the object. Typically you would see this when you were dealing with a list of Animals or if you were writing a method that took an animal as a parameter or returned one but you didn't want to make the method specific to Dog type objects.

Look up some info on polymorphism that should help you get a better understanding.

Improve this answer

Comments

0

This concept is called 'Programe to an interface not to an implementation' , here interface does not mean actual c# interface it can be a base class , abstract class and it is a very popular concept in OO world which is a base for other concepts like 'Dependency Injection' , 'IOC (Inversion of Control)'

Like Eric already stated that

if you know in Advance that you are actually going to create a Dog object than using Interfaced based technique is less impact BUT its actual power comes when you use a Factory method which returns a Animal and you actually till Runtime does not know the concrete type.

Improve this answer

Comments

0

What you're seeing is the other side of inheritance. Inheritance is not just saving yourself rewriting features that exist in another class.

The idea is that if you design the class hierarchy properly, you can use your classes in a safer way throughout your code (Thanks to the fact that C# is strongly typed). And of course re-use code that might be used for a whole family of objects, rather then rewrite it for each class.

Lets analyze the strength of the example you gave us.

Because you have a known Interface called Animal, you don't need to know all the animal types that exist throughout the program (classes that implement the interface).

This allows you to make code like this:

public interface Animal
    {
        void Play();
        void WagTale();
        void Eat(Food food);
    }
}


void PlayWithAnimal(Animal animal) {
   animal.WagTale();
   this.ThrowBall();
   animal.Play();
   animal.WaTale();
}

This will work just the same for any other animal class that implements that interface, no matter how it's implemented.

So you can call the method like this:

Dog dog = new Dog();
Lion lion = new Lion();
Flee flee = new Flee();
PlayWithAnimal(dog);
PlayWithAnimal(lion);
PlayWithAnimal(flee);

Again, the idea is to be able to categorize your classes and use the most basic elements that use the same methods and members in your code.

A more C# oriented example: Image is an abstract class, you can't even create an instance of such an object. But there are a lot of other classes that derive from Image, so although no object can be a real Image, you'll mostly see Image in code that uses Images. (Again mostly the image actually be Bitmap or some other class)

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.