CODEWITHSUNDEEP
javapolymorphism
Assaf
Assaf

Reputation: 1124

Polymorphism vs Inheritance

Suppose I have two classes: Animal and Dog. Dog is a subclass of Animal. I do the following code:

Animal a = new Dog();

Now I can call methods of the Dog class through the a variable.

But my question is this: if I can call all of Animal's methods through the Dog objects (inheritance) than why should I use the polymorphism principle? I can just declare:

Dog d = new Dog();

With this declaration can use all of Animal's methods and Dog methods. So why use polymorphism? Thank you very much for your answer.

Upvotes: 21

Views: 21662

Answers (6)

Alireza Rahmani Khalili
Alireza Rahmani Khalili

Reputation: 2954

inheritance is the dynamic polymorphism. I mean when you remove inheritance you can not override anymore.

Upvotes: 0

Jakub Kubrynski
Jakub Kubrynski

Reputation: 14149

Normally the question you've asked is more similar to Inheritance vs Composition :) More "real life" example of why it's good to use polymorphism is for example usage of strategy design pattern. You can have many TaxPolicy implementation: UsaTaxPolicy, CanadaTaxPolicy, EuTaxPolicy, etc. If you have method calculateFinalPrice, which have to also calculate tax, then you inject the proper implementation and good calculation is executed, no matter you've passed Usa, Canada or Eu implementation.

Upvotes: 0

Peter Rasmussen
Peter Rasmussen

Reputation: 16922

If you are certain that it will always be a dog there is no reason for it. You might aswell use Dog d = new Dog(); as you described. But let's say you used a method instead of a constructor. The method returned an animal and you wouldn't know which implementation of animal you would get. You would still be able to use the same methods on the animal (even if it's a Dog, Elephant cat etc).

For extensibility purposes inheritance simplifies things. When you want to create an elephant or cat which also share some animal methods, You can easily get those by having animal as super class.

Upvotes: 1

Sergey Kalinichenko
Sergey Kalinichenko

Reputation: 726559

In Java, the concepts of polymorphism and inheritance are "welded together"; in general, it does not have to be that way:

  • Polymorphism lets you call methods of a class without knowing the exact type of the class
  • Inheritance lets derived classes share interfaces and code of their base classes

There are languages where inheritance is decoupled from polymorphism:

  • In C++ you can inherit a class without producing polymorphic behavior (i.e. do not mark functions in the base class with virtual)
  • In Objective C you can implement a method on an unrelated class, and call it from a place that knows only the signature of the method.

Going back to Java, the reason to use polymorphism is decoupling your code from the details of the implementation of its counter-parties: for example, if you can write a method Feed(Animal animal) that works for all sorts of animals, the method would remain applicable when you add more subclasses or implementations of the Animal. This is in contrast to a Feed(Dog dog) method, that would be tightly coupled to dogs.

As far as the

Dog d = new Dog();

declaration goes, there is no general reason to avoid this if you know that the rest of your method deals specifically with dogs. However, in many cases the later is not the case: for example, your class or your methods would often be insensitive to the exact implementation, for example

List<Integer> numbers = new ArrayList<Integer>();

In cases like that, you can replace new ArrayList<Integer>() with new LinkedList<Integer>(), and know that your code is going to compile. In contrast, had your numbers list been declared as ArrayList<Integer> numbers, such switchover may not have been a certainty.

This is called "programming to an interface". There is a very good answer on Stack Overflow explaining it.

Upvotes: 25

NPE
NPE

Reputation: 500327

Polymorphism allows you to write a method that works for any Animal:

public void pet(Animal animal) {
   ...
}

This method would accept Dog, Cat, etc, including subclasses of Animal that are yet to be written.

If the method were to take Dog, it would not work for Cat etc.

Upvotes: 4

rgettman
rgettman

Reputation: 178263

You can have other implementations of the Animal class, such as Cat. Then you can say

Animal a = new Dog();
Animal b = new Cat();

You can call methods of the Animal class without caring which implementation it really is, and polymorphism will call the correct method. E.g.

a.speak();  // "Woof"

b.speak();  // "Meow"

Really, it's not "Polymorphism vs Inheritance" but "Polymorphism using Inheritance".

Upvotes: 5

Related Questions