polymorphism vs inheritence as the pillars of oop

Question

As stated here

https://standardofnorms.wordpress.com/2012/09/02/4-pillars-of-object-oriented-programming/

and as the correct answer in many job interviews - the general correct answer for the question: "What are the 4 pillars of OOP?" is:

Abstraction
Encapsulation
Inheritance
Polymorphism

What I fail to understand is how inheritance not contained in polymorphism?

in other words, how can polymorphism be used without the use of inheritance?

The only way I know of using polymorphism is

class A{ virtual void foo(){cout<<"A";} void bar(){cout<<"A";} }; class B : public A{ virtual foo(){cout<<"B";} }; A* ab = new B(); ab->foo();//prints B, using polymorphism ab->bar();//prints A, using inheritance A* a = new A(); a->foo();//prints A a->bar();//prints A, obviously

As I see it, polymorphism brings with it inheritance.

Please explain why it is distinct - or why can't inheritance be discarded as a key pillar of its own. We could use polymorphism or not.

Think about interfaces -- implementations do not have to be made in related classes. — dbugger
– dbugger, Commented Jul 12, 2016 at 14:03

jmrah · Accepted Answer · 2016-07-12 14:44:04Z

What I fail to understand is how inheritence not contained in polymorphism?

in other words, how can polymorphism be used without the use of inheritence?

There are 3 main types of polymorphism, and only one of them requires inheritance to work.

Ad-hoc polymorphism: This is more commonly known as function/method overloading, where multiple functions can share the same name but have different signatures. Whether or not the return type is part of the signature is language dependent.
Parametric polymorphism: in OOP, this is more commonly known as generics, where a function/method can work with multiple concrete types, and return multiple concrete types, providing compile time safety.
Subtype polymorphism: This is the one I think most people think of when they talk about polymorphism. As you know, this is when subtypes provide different implementation of their parent functions/methods.

You can read more about the different types of polymorphism from the wikipedia article here: https://en.wikipedia.org/wiki/Polymorphism_(computer_science)

Yes, you are right. The return type can differ as long as the argument signature differs (at least in Java, not sure about other languages). I'll clarify the answer.

Community · Accepted Answer · 2017-05-23 12:32:38Z

As I understand the two concepts:

Inheritance

You could use inheritance without using polymorphisim. For example:

class Base { public: void foo(); }; class Derived : public Base { }; int main() { Derived d; d.foo(); }

Here we use the common functionality of the base type in all derived types, but at no point do we do anything polymophic (we never look at the derived instance though its base interface).

Polymorphism

Polymorphism as a concept includes more than the standard inheritance based method seen most often. This is actually subtyping which is just one kind of Polymorphism.

Writing a template method is technically a form of polymophism, and function overloading another. As a concept you could argue that many other things are ways to achieve polymophism.

For example:

// This function must be given an object that has a method foo(). template <typename T> bar(T& t) { t.foo(); }

This is polymorphic behavior without inheritance.

See: https://stackoverflow.com/a/10556406/1230538 for a really good explaination of this given by someone else.

Summary

99% you use inheritance to achieve polymorphism in most modern programming languages, but they are different concepts, and can exist/be used independently of each other.

Ilya Vassilevsky · Accepted Answer · 2016-07-12 14:12:31Z

Polymorphism without inheritance:

class A { virtual void foo() { cout << "A"; } }; class B { virtual void foo() { cout << "B"; } }; A* a = new A(); A* b = new B(); a->foo(); // prints A b->foo(); // prints B

Both instances have the same method. So they are polymorphic. However, the method does different things because the objects are different after all.

This won't compile. A* b = new B(); rhs argument is of type B* which is not a A*

Collectives™ on Stack Overflow

polymorphism vs inheritence as the pillars of oop

3 Answers 3

2 Comments

Comments

1 Comment

Linked

Hot Network Questions