What is polymorphism, what is it for, and how is it used?

Asked 23/6, 2009 at 8:14 Answered 29/12, 2022 at 9:33

Solved oop polymorphism computer-science

643

What is polymorphism, what is it for, and how is it used?

Obnoxious answered 23/6, 2009 at 8:14 Comment(17)

I defined it here (copying from Wikipedia) when someone asked if it was the same as overloading (which is not): #825263 – Flee 23/6, 2009 at 8:16

@John Nolan, @Aamir: It's not perfect and the user has been mainly active in tags such as php, subjective, python, regex, mysql, javascript, web development... which may not be the most related to pure OO concepts such as polymorphism. – Flee 23/6, 2009 at 8:22

I think this is a valid question, no reason for a downvote. +1 – Glissando 23/6, 2009 at 8:22

@John: +1 I agree that is a most interesting phenomenon. I'm sure that Unkwntech is not the only knowledgable, capable individual to have gaps in what others would consider to be a fundemental vocabulary. Just goes to show programming is a very wide subject. – Affinity 23/6, 2009 at 8:22

He might use it, just not give it a name. – Agripina 23/6, 2009 at 8:24

@Aamir: I'm not sure that reasonable to assume that someone with 8k would know all fundementals in all areas of programming. Also I don't think it indicates the reputation system is imperfect. Someone can gain considerable reputation by asking a lot of good questions. I think our natural response to this revelation simply demonstrates the we (programmers) have a natural tendency to be a little narrow minded (not a bad thing when we need to be really good in some specific technical area) and that has its downsides. – Affinity 23/6, 2009 at 8:28

@AnthonyWJones: Still, anyone with a basic programming education should know about Polymorphism. Well, it is quite possible that this guy is self-taught and never had a reason to look into it but if that is the case, then You are absolutely right. As far as rating system is concerned, you know it is a little flawed when questions like "How to date a female programmer" can get you huge reputation. #80384 – Canterbury 23/6, 2009 at 8:33

@Aamir: Did you note that 79884 and its answers are community wiki? There is nothing flawed in the reputation system when you understand the mechanism. – Affinity 23/6, 2009 at 8:39

@Aamir, Aiden: The last two comments would apply to lots of other questions here. What is unit testing? What are assertions? And not everybody learns to develop software via the OOP paradigm (although I did it this way and I find it great). – Flee 23/6, 2009 at 8:41

@Aiden: The answer to your question is "inheritance". So much modern discussion revolves around the construction of classes, encapsulation and then the complexities of inheritance that provide "code re-use" that the true benefit of re-use due polymorphism is missed. Polymorphism is presented as a quick "so finally we can do this, ta-da!" and often its not even named "polymorphism" just left as another way we can reuse code written for an interface or a base class. If you've read a good book or studied it formally this wouldn't be the case but if you are self taught it can be. – Affinity 23/6, 2009 at 8:46

@Daniel - I agree with you. I avoid OOP when there is choice ... but even in non-OOP these are essential "patterns" – Agripina 23/6, 2009 at 8:47

@Affinity - I agree, and in a previous comment stated that it might be used without knowing the term. – Agripina 23/6, 2009 at 8:48

You guys seem to have have a very limited view of programming. I know guys who are doing embedded development that have no knowledge of (or need for) OO concepts at all. Their brief is to wring every last atom of performance from the code and that's it - the code they're working on will never enter the world of objects, and they're luckily close enough to retirement that they don't have to worry about learning new-fangled concepts like objects, polymorphism and variable names with more than two letters :-) – Limnetic 23/6, 2009 at 9:6

@Pax: I can remember back doing embedded assembler based development. Interestingly the concept of message passing between different facilities used in embedded systems had a striking similarity to the new fangled OO stuff at the time. Today this concept is coming back in fashion as an alternative to the functional approach to make better use of multi-cores for example the Axum language. – Affinity 23/6, 2009 at 10:50

How do you learn something? No-one came into this world knowing PHP OOP and design patterns, so all of you at some point had to learn it, at college, an answer here, etc. Don't talk about someone "dared not to already know complex code procedures", and instead consider they are here wanting to learn it, which is a good thing & the point of this site. Use your time helping them, as I'm sure you've been helped in the past. If throughout the history of man, instead of sharing knowledge, the response was "What? ha! you don't know that?.." we'd all still be in the dark ages.. – Lenhard 13/2, 2014 at 17:34

It's a trick in OOP which It's give you an ability to write the number of various objects underlying a specific type. So it reduces codes and increases flexibility of the objects, beside of simplifying debugging and updates. – Ivar 26/9, 2018 at 11:16

@Limnetic “new-fangled concepts like objects, polymorphism” → Erm, polymorphism dates back from years 196x. Wikipedia mentions Algol68 (1968, ad-hoc polymorphism) and ML (1973, parametric polymorphism). Besides, polymorphism is not exclusively an OO concept (some forms of polymorphism are). – Godly 4/6, 2022 at 22:53

610

If you think about the Greek roots of the term, it should become obvious.

Poly = many: polygon = many-sided, polystyrene = many styrenes ^(a), polyglot = many languages, and so on.
Morph = change or form: morphology = study of biological form, Morpheus = the Greek god of dreams able to take any form.

So polymorphism is the ability (in programming) to present the same interface for differing underlying forms (data types).

For example, in many languages, integers and floats are implicitly polymorphic since you can add, subtract, multiply and so on, irrespective of the fact that the types are different. They're rarely considered as objects in the usual term.

But, in that same way, a class like BigDecimal or Rational or Imaginary can also provide those operations, even though they operate on different data types.

The classic example is the Shape class and all the classes that can inherit from it (square, circle, dodecahedron, irregular polygon, splat and so on).

With polymorphism, each of these classes will have different underlying data. A point shape needs only two co-ordinates (assuming it's in a two-dimensional space of course). A circle needs a center and radius. A square or rectangle needs two co-ordinates for the top left and bottom right corners and (possibly) a rotation. An irregular polygon needs a series of lines.

By making the class responsible for its code as well as its data, you can achieve polymorphism. In this example, every class would have its own Draw() function and the client code could simply do:

shape.Draw()

to get the correct behavior for any shape.

This is in contrast to the old way of doing things in which the code was separate from the data, and you would have had functions such as drawSquare() and drawCircle().

Object orientation, polymorphism and inheritance are all closely-related concepts and they're vital to know. There have been many "silver bullets" during my long career which basically just fizzled out but the OO paradigm has turned out to be a good one. Learn it, understand it, love it - you'll be glad you did :-)

^(a) I originally wrote that as a joke but it turned out to be correct and, therefore, not that funny. The monomer styrene happens to be made from carbon and hydrogen, C₈H₈, and polystyrene is made from groups of that, (C₈H₈)_n.

Perhaps I should have stated that a polyp was many occurrences of the letter p although, now that I've had to explain the joke, even that doesn't seem funny either.

Sometimes, you should just quit while you're behind :-)

Limnetic answered 23/6, 2009 at 8:44 Comment(15)

Polymorphism is not related to OOP, but OOP is related to polymorphism because it inherently supports it (assuming its a decent OOP language). Look at FP for other examples of polymorphism. – Biped 16/4, 2011 at 20:27

I'd like to rise simple question about polymorphism. Is function that takes base type as its argument (ex void foo(Base &x) in C++) can be considered polymorphic? Note that we shouldn't consider the fact that final code will have only one body of that function since optimizer can make different bodies optimized differently and can have different behavior. Of course compiler should be able to prove that type of objects received by that function can be determined in compile time which is easy to do if your code is foo(DerivedA()); foo(DerivedB());. – Meredithmeredithe 17/5, 2013 at 9:51

These 2 lines did the trick for me: Poly = many and Morph = change or form – Refresher 13/5, 2014 at 9:48

Polyp is short for polypo(u)s. And pous is foot in greek. ;-) – Millford 12/10, 2016 at 14:21

This answer describes subtyping which is but one form of polymorphism. en.wikipedia.org/wiki/Subtyping – Valles 29/1, 2017 at 2:1

Shaun, the paragraph immediately after the bullet points is the definitive (literally) one and makes no such limitation to said definition. Everything after that is just examples of polymorphism. – Limnetic 29/1, 2017 at 2:39

Yeah @ShaunLuttin, actually it recently came to my knowledge another nice type of polimorphism called polimorphism by composition, you guys take a look on that: en.wikipedia.org/wiki/Composition_over_inheritance – Synchrotron 18/4, 2017 at 0:54

@Limnetic The paragraph immediately after the bullet points does not match my understanding. Polymorphism lets us run the same routine/operation on different types at different times. One way to do that is to present the same interface for different underlying types. Another way to do that is method overloading (ad hoc polymorphism) which does not require presenting the same interface for different underlying types. The definitive paragraph from your answer leaves out that way of doing it. – Valles 18/4, 2017 at 1:32

@Shaun, I think you may be using the term "interface" in a far too-literal/constrictive sense - I meant it as an English term rather than a definition specific to some arbitrary computer language. It doesn't mean exactly the same function with exactly the same parameters, it's simply a way of affecting "objects" in the same way irrespective of their underlying concrete type. This can include method overloading with different parameter types as well as the more pure form of polymorphism. – Limnetic 18/4, 2017 at 3:21

"(...) integers and floats are implicitly polymorphic since you can add, subtract, multiply (...), irrespective of the fact that the types are different" - is this statement true in general, for every programming language? It is true for languages like C++ (when using templates) or JavaScript, but what about e.g. C#? I don't think we are able to have a method in C# that uses number operators without knowing on which exact type it operates on. – Illume 9/9, 2017 at 8:22

Explicitly wrong about linking inheritance with polymorphism. Anyone who tries the understand deeply concept will misguided with this way. Also the very starting thought regarding numbers although may be true, is not useful, especially as a first thought. Does not mention the "is a" relation... – Fairtrade 19/3, 2019 at 8:5

@g.pickardou, the sentence linking those two begins "The classic example ...", it's not meant to be a restrictive requirement that all polymorpism is related to inheritance. I'm well aware that polymorphism can have other means of expression (such as interfaces) but I'm also aware that, should I attempt an exhaustive answer, it would be so voluminous as to be useless :-) If you have some specific suggestions on how to improve the answer, I'm happy to entertain them. – Limnetic 20/3, 2019 at 6:51

Regarding your edit : “Explaining a joke is like dissecting a frog. You understand it better but the frog dies in the process.” - E.B. White – Hamrnand 13/6, 2019 at 15:51

in many languages, integers and floats are implicitly polymorphic since you can add, subtract, multiply and so on Wouldn't you say that actually it is the operators (+-*/, etc) which are polymorphic? Or is it correct to say that only the operands are polymorphic? Perhaps both? – Ismaelisman 23/1, 2020 at 8:57

"So polymorphism is the ability (in programming) to present the same interface for differing underlying forms (data types)." To me, hearing about form implies interface -- the visual perception. So I would expect "many forms" to mean that the form changes, not the internals (implementation). – Inkwell 9/2, 2022 at 10:17

300

Polymorphism is when you can treat an object as a generic version of something, but when you access it, the code determines which exact type it is and calls the associated code.

Here is an example in C#. Create four classes within a console application:

public abstract class Vehicle
{
    public abstract int Wheels;
}

public class Bicycle : Vehicle
{
    public override int Wheels()
    {
        return 2;
    }
}

public class Car : Vehicle
{
    public override int Wheels()
    {
        return 4;
    }
}

public class Truck : Vehicle
{
    public override int Wheels()
    {
        return 18;
    }
}

Now create the following in the Main() of the module for the console application:

public void Main()
{
    List<Vehicle> vehicles = new List<Vehicle>();

    vehicles.Add(new Bicycle());
    vehicles.Add(new Car());
    vehicles.Add(new Truck());

    foreach (Vehicle v in vehicles)
    {
        Console.WriteLine(
            string.Format("A {0} has {1} wheels.",
                v.GetType().Name, v.Wheels));
    }
}

In this example, we create a list of the base class Vehicle, which does not know about how many wheels each of its sub-classes has, but does know that each sub-class is responsible for knowing how many wheels it has.

We then add a Bicycle, Car and Truck to the list.

Next, we can loop through each Vehicle in the list, and treat them all identically, however when we access each Vehicles 'Wheels' property, the Vehicle class delegates the execution of that code to the relevant sub-class.

This code is said to be polymorphic, as the exact code which is executed is determined by the sub-class being referenced at runtime.

I hope that this helps you.

Squadron answered 24/6, 2010 at 13:25 Comment(4)

I think this is a very good example for showing clearly the parent interface, and that it is not until the object is instantiated that a concrete version is required, ie vehicle vs car – Tito 30/10, 2014 at 2:9

I would say this is the clearest example, though if you are a PHP programmer this link might be easier to review FIRST, and then still look at this one after: code.tutsplus.com/tutorials/… – Parrie 6/1, 2017 at 19:50

Also (beyond the scope of the OP) to note that we're constraining analysis to known objects; we are not passing an object (like an import file) and then determining what type it is (Excel, CSV, YAML, SQL, etc. etc.). To do this one would need some sort of factory class for Class_Excel, Class_CSV to be called, or have a Reader class called. Either way, some sort of iterative if/then/else is going to have to be stored somewhere. – Parrie 6/1, 2017 at 19:54

@Antony Gibbs: this is a really good example (a list of the generic types) that makes sense to me....otherwise what is the big deal of having each class have it's own wheels function without inheriting from a base class? Are there any more concepts besides list that would be good for polymorphic? – Doerrer 25/1, 2018 at 23:21

212

From Understanding and Applying Polymorphism in PHP, Thanks Steve Guidetti.

Polymorphism is a long word for a very simple concept.

Polymorphism describes a pattern in object oriented programming in which classes have different functionality while sharing a common interface.

The beauty of polymorphism is that the code working with the different classes does not need to know which class it is using since they’re all used the same way. A real world analogy for polymorphism is a button. Everyone knows how to use a button: you simply apply pressure to it. What a button “does,” however, depends on what it is connected to and the context in which it is used — but the result does not affect how it is used. If your boss tells you to press a button, you already have all the information needed to perform the task.

In the programming world, polymorphism is used to make applications more modular and extensible. Instead of messy conditional statements describing different courses of action, you create interchangeable objects that you select based on your needs. That is the basic goal of polymorphism.

Chronologist answered 4/11, 2011 at 5:17 Comment(4)

isn't the button analogy related more to the concept of abstraction? – Conclusion 29/3, 2013 at 3:53

Original source: code.tutsplus.com/tutorials/… – Holzman 16/3, 2015 at 14:14

@Mantriur: This is indeed plagiarized, and we have rules against that: stackoverflow.com/help/referencing But given its score now and the fact that old posts are exempt from rep loss on answer deletion, I'm not sure if deleting it now outright would improve anything. The next best alternative would be to just edit in the attribution on behalf of the user, even though I strongly believe users are responsible for citing sources in their own answers. – Fenestella 16/3, 2015 at 15:10

I believe it is incorrect to imply that polymorphism is specific to classes and/or object-oriented programming, seeing how ad hoc polymorphism or parametric polymorphism do not necessarily require classes and/or objects. I think what this answer is talking about is subtyping(also known as subtype polymorphism or inclusion polymorphism). – Outboard 18/10, 2016 at 6:54

If anybody says CUT to these people

The Surgeon
The Hair Stylist
The Actor

What will happen?

The Surgeon would begin to make an incision.
The Hair Stylist would begin to cut someone's hair.
The Actor would abruptly stop acting out of the current scene, awaiting directorial guidance.

So above representation shows What is polymorphism (same name, different behavior) in OOP.

If you are going for an interview and interviewer asks you tell/show a live example for polymorphism in the same room we are sitting at, say-

Answer - Door / Windows

Wondering How?

Through Door / Window - a person can come, air can come, light can come, rain can come, etc.

To understand it better and in a simple manner I used above example.. If you need reference for code follow above answers.

Trapan answered 15/11, 2014 at 11:48 Comment(1)

I don't think this is a great example because it may lead inexperienced people to think that if two classes have a .foo() method, then they should share a common interface. However, this isn't true and leads to incorrect abstractions. An interface should define a role that is to be played, which may have many different implementations, but all pull from the same set of input and return something from the same set of output. The input into a x.cut(...) for a surgeon, stylist, or actor aren't the same, and neither is the output. – Forestation 27/1, 2017 at 5:49

Simple Explanation by analogy

The President of the United States employs polymorphism. How? Well, he has many advisers:

Military Advisers
Legal Advisers
Nuclear physicists (as advisers)
etc etc.

The president is not an expert in zinc coating, or quantum physics. He doesn't know many things. And he doesn't need to know. He utilizes a polymorophic approach to governing:

All the president does is ask people to advise him. His advisors all respond differently, but they all know what the president means by: Advise().

public class MisterPresident
{
    public void RunTheCountry()
    {
        // assume the Petraeus and Condi classes etc are instantiated.
        petraeus.Advise(); // # Petraeus says send 100,000 troops to Fallujah
        condolezza.Advise(); // # she says negotiate trade deal with Iran
        healthOfficials.Advise(); // # they say we need to spend $50 billion on ObamaCare
    }
}

This approach allows the president to run the country literally without knowing anything about military stuff, or health care or international diplomacy: the details are left to the experts. The only thing the president needs to know is is to ask people to: "Advise()".

What you DON"T want:

public class MisterPresident
{
    public void RunTheCountry()
    {
        // people walk into the Presidents office and he tells them what to do
        // depending on who they are.

        // Fallujah Advice - The President tells his military exactly what to do.
        petraeus.IncreaseTroopNumbers();
        petraeus.ImproveSecurity();
        petraeus.PayContractors();

        // Condi diplomacy advice - Prez tells Condi how to negotiate

        condi.StallNegotiations();
        condi.LowBallFigure();
        condi.FireDemocraticallyElectedIraqiLeaderBecauseIDontLikeHim();

        // Health care

        healthOfficial.IncreasePremiums();
        healthOfficial.AddPreexistingConditions();
    }
}

NO! NO! NO! In the above scenario, the president is doing all the work. He is telling his advisors what to do, rather than the other way around. The president he knows about increasing troop numbers and pre-existing conditions. This means that if policies change, then the president would have to change his commands, as well as the Petraeus class as well.

We should only have to change the Petraeus class, because the President shouldn't have to get bogged down in that sort of detail. All he needs to know is that if he makes one order, everything will be taken care of. All the details should be left to the experts.

This allows the president to do what he does best: set general policy, look good and play golf :P.

How is it actually implemented - through a base class or a common interface

That in effect is polymorphism, in a nutshell.

How exactly is it done? Through "implementing a common interface" or by using a base class (inheritance) - see the above answers which detail this more clearly. (In order to more clearly understand this concept you need to know what an interface is, and you will need to understand what inheritance is. Without that, you might struggle.)

In other words, Petraeus, Condi and HealthOfficials would all be classes which "implement an interface" - let's call it the IAdvisor interface which just contains one method: Advise(). But now we are getting into the specifics.

This would be ideal

    public class MisterPresident
    {
            // You can pass in any advisor: Condi, HealthOfficials,
            //  Petraeus etc. The president has no idea who it will 
            // be. But he does know that he can ask them to "advise" 
            // and that's all Mr Prez cares for.

        public void RunTheCountry(IAdvisor governmentOfficer)
        {             
            governmentOfficer.Advise();              
        }
    }


    public class USA
    {
        MisterPresident president;

        public USA(MisterPresident president)
        {
            this.president = president;
        }

        public void ImplementPolicy()
        {
            IAdvisor governmentOfficer = getAdvisor(); // Returns an advisor: could be condi, or petraus etc.
            president.RunTheCountry(governmentOfficer);
        }
    }

Summary

All that you really need to know is this:

The president doesn't need to know the specifics - those are left to others.
All the president needs to know is to ask who ever walks in the door to advice him - and we know that they will absolutely know what to do when asked to advise (because they are all in actuality, advisors (or IAdvisors :) )

I hope it helps. If you don't understand anything post a comment and i'll try again.

Mccully answered 29/10, 2016 at 0:17 Comment(8)

Fantastic example! Thanks. – Bula 9/1, 2017 at 9:6

Very interesting analogy. Thank you. – Gerfalcon 16/8, 2017 at 2:33

@bkspurgeon: why cant we jsut wrap the 3 separate calls in one function to abstract it? why polymorphism here? heck just wrap all advisors in 1 function? – Doerrer 25/1, 2018 at 23:41

@Doerrer because (1) everytime you have a new advisor then you'd have to change the president class - you don't want to make x2 changes. just one. (2) secondly, if you have to change an existing advisor, then you might have to go back and change one of those three calls in the president class - you only really want to make one change, not two. (3) if you had three separate calls then you would have to ask, within the president class: if healthAdvisor? then do this: and if petraus then do that etc. this pattern will need to be repeated and that is unecessary and complicated. see above edit. – Mccully 25/1, 2018 at 23:53

@bkspurgeon: Hi, for point (1), I only see that in your last "ideal" code example, where you pass in the advisor, otherwise in the first example, it seems there would be a change to the president class if you got a new advisor...right? for point (2), sure three calls instead of one, but I guess I still just see that is abstraction via 1 function call. Your last example in contrast with the what not to do example helps the most, (even thought you added a new type of "IAdvisor ", may be helpful to describe that). ...thanks for helping me understand. – Doerrer 26/1, 2018 at 0:9

@Doerrer yes you are right. but i have to slowly introduce the concept to the readers otherwise they will not understand. i have added further changes. please advise if clarifications are needed – Mccully 26/1, 2018 at 0:10

@bkspurgeon: awesome, yes now i see it coming together. Haven't seen the terms base class and interface used exchangeable before, but if that is OK in OOP, it makes sense. thank you for you slowly introducing the concepts, yes that does help. – Doerrer 26/1, 2018 at 0:19

@Doerrer base class vs interface is a design decision programmers have to make when doing polymorpism. see here for more details: https://mcmap.net/q/16136/-interface-vs-base-class – Mccully 26/1, 2018 at 0:42

Polymorphism is the ability to treat a class of object as if it is the parent class.

For instance, suppose there is a class called Animal, and a class called Dog that inherits from Animal. Polymorphism is the ability to treat any Dog object as an Animal object like so:

Dog* dog = new Dog;
Animal* animal = dog;

Dactylology answered 23/6, 2009 at 8:20 Comment(3)

I wonder how is this related to the (popular) explanation that @Ajay Patel gave classes have different functionality while sharing a common interface – Strictly 5/5, 2014 at 10:44

@Strictly The parent class is/provides that common interface. – Magic 8/8, 2014 at 14:42

Polymorphism does not require subtyping. – Valles 29/1, 2017 at 1:1

Polymorphism:

It is the concept of object oriented programming.The ability of different objects to respond, each in its own way, to identical messages is called polymorphism.

Polymorphism results from the fact that every class lives in its own namespace. The names assigned within a class definition don’t conflict with names assigned anywhere outside it. This is true both of the instance variables in an object’s data structure and of the object’s methods:

Just as the fields of a C structure are in a protected namespace, so are an object’s instance variables.
Method names are also protected. Unlike the names of C functions, method names aren’t global symbols. The name of a method in one class can’t conflict with method names in other classes; two very different classes can implement identically named methods.

Method names are part of an object’s interface. When a message is sent requesting that an object do something, the message names the method the object should perform. Because different objects can have methods with the same name, the meaning of a message must be understood relative to the particular object that receives the message. The same message sent to two different objects can invoke two distinct methods.

The main benefit of polymorphism is that it simplifies the programming interface. It permits conventions to be established that can be reused in class after class. Instead of inventing a new name for each new function you add to a program, the same names can be reused. The programming interface can be described as a set of abstract behaviors, quite apart from the classes that implement them.

Examples:

Example-1: Here is a simple example written in Python 2.x.

class Animal:
    def __init__(self, name):    # Constructor of the class
        self.name = name
    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        return 'Meow!'

class Dog(Animal):
    def talk(self):
        return 'Woof! Woof!'

animals = [Cat('Missy'),
           Dog('Lassie')]

for animal in animals:
    print animal.name + ': ' + animal.talk()

Example-2: Polymorphism is implemented in Java using method overloading and method overriding concepts.

Let us Consider Car example for discussing the polymorphism. Take any brand like Ford, Honda, Toyota, BMW, Benz etc., Everything is of type Car.

But each have their own advanced features and more advanced technology involved in their move behavior.

Now let us create a basic type Car

Car.java

public class Car {

    int price;
    String name;
    String color;

    public void move(){
    System.out.println("Basic Car move");
    }

}

Let us implement the Ford Car example.

Ford extends the type Car to inherit all its members(properties and methods).

Ford.java

public class Ford extends Car{
  public void move(){
    System.out.println("Moving with V engine");
  }
}

The above Ford class extends the Car class and also implements the move() method. Even though the move method is already available to Ford through the Inheritance, Ford still has implemented the method in its own way. This is called method overriding.

Honda.java

public class Honda extends Car{
  public void move(){
    System.out.println("Move with i-VTEC engine");
  }
}

Just like Ford, Honda also extends the Car type and implemented the move method in its own way.

Method overriding is an important feature to enable the Polymorphism. Using Method overriding, the Sub types can change the way the methods work that are available through the inheritance.

PolymorphismExample.java

public class PolymorphismExample {
  public static void main(String[] args) {
    Car car = new Car();
    Car f = new Ford();
    Car h = new Honda();

    car.move();
    f.move();
    h.move();

  }
}

Polymorphism Example Output:

In the PolymorphismExample class main method, i have created three objects- Car, Ford and Honda. All the three objects are referred by the Car type.

Please note an important point here that A super class type can refer to a Sub class type of object but the vice-verse is not possible. The reason is that all the members of the super class are available to the subclass using inheritance and during the compile time, the compiler tries to evaluate if the reference type we are using has the method he is trying to access.

So, for the references car,f and h in the PolymorphismExample, the move method exists from Car type. So, the compiler passes the compilation process without any issues.

But when it comes to the run time execution, the virtual machine invokes the methods on the objects which are sub types. So, the method move() is invoked from their respective implementations.

So, all the objects are of type Car, but during the run time, the execution depends on the Object on which the invocation happens. This is called polymorphism.

Aright answered 5/2, 2013 at 13:41 Comment(2)

Overloading concept has nothing to do with inheritance and Polymorphism. – Bonine 8/1, 2017 at 10:41

@Bonine Method overloading is one way of implementing polymorphism. It's often categorized as static or ad hoc polymorphism. wiki.c2.com/?CategoryPolymorphism – Valles 29/1, 2017 at 2:6

Usually this refers the the ability for an object of type A to behave like an object of type B. In object oriented programming this is usually achieve by inheritance. Some wikipedia links to read more:

EDIT: fixed broken links.

Mho answered 23/6, 2009 at 8:18 Comment(4)

"the ability for an object of type A to behave like an object of type B" - it's not accurate definition. I would say it's more like the ability to treat an object of type A like it's an object of type B. – Emmen 23/6, 2009 at 8:27

Yes. Maybe that is a better phrasing. – Mho 23/6, 2009 at 8:37

For completeness, many language implement polymorphism through duck typing, e.g. Python. – Moskva 29/6, 2009 at 16:40

I wonder how is this related to the (popular) explanation that @Ajay Patel gave classes have different functionality while sharing a common interface – Strictly 5/5, 2014 at 10:46

Polymorphism is this:

class Cup {
   int capacity
}

class TeaCup : Cup {
   string flavour
}

class CoffeeCup : Cup {
   string brand
}

Cup c = new CoffeeCup();

public int measure(Cup c) {
    return c.capacity
}

you can pass just a Cup instead of a specific instance. This aids in generality because you don't have to provide a specific measure() instance per each cup type

Zounds answered 24/6, 2010 at 13:7 Comment(2)

This is specifically subtype polymorphism. – Valles 29/1, 2017 at 1:5

@vinko-vrsalovic: what is software development like in rural America? – Doerrer 25/1, 2018 at 23:44

I know this is an older question with a lot of good answers but I'd like to include a one sentence answer:

Treating a derived type as if it were it's base type.

There are plenty of examples above that show this in action, but I feel this is a good concise answer.

Derril answered 17/10, 2012 at 21:18 Comment(3)

This is subtyping, which is only one kind of polymorphism. – Valles 29/1, 2017 at 1:6

@ShaunLuttin can you point me to any resources to learn more about the other types of polymorphism? – Derril 29/1, 2017 at 1:8

The are "ad hoc polymorphism" and "parameteric polymorphism" in addtion to "subtype polymorphism". – Valles 29/1, 2017 at 1:17

(I was browsing another article on something entirely different.. and polymorphism popped up... Now I thought that I knew what Polymorphism was.... but apparently not in this beautiful way explained.. Wanted to write it down somewhere.. better still will share it... )

http://www.eioba.com/a/1htn/how-i-explained-rest-to-my-wife

read on from this part:

..... polymorphism. That's a geeky way of saying that different nouns can have the same verb applied to them.

Molina answered 14/1, 2014 at 10:59 Comment(0)

Generally speaking, it's the ability to interface a number of different types of object using the same or a superficially similar API. There are various forms:

Function overloading: defining multiple functions with the same name and different parameter types, such as sqrt(float), sqrt(double) and sqrt(complex). In most languages that allow this, the compiler will automatically select the correct one for the type of argument being passed into it, thus this is compile-time polymorphism.
Virtual methods in OOP: a method of a class can have various implementations tailored to the specifics of its subclasses; each of these is said to override the implementation given in the base class. Given an object that may be of the base class or any of its subclasses, the correct implementation is selected on the fly, thus this is run-time polymorphism.
Templates: a feature of some OO languages whereby a function, class, etc. can be parameterised by a type. For example, you can define a generic "list" template class, and then instantiate it as "list of integers", "list of strings", maybe even "list of lists of strings" or the like. Generally, you write the code once for a data structure of arbitrary element type, and the compiler generates versions of it for the various element types.

Vociferation answered 23/6, 2009 at 8:52 Comment(0)

The term polymorphism comes from:

poly = many

morphism = the ability to change

In programming, polymorphism is a "technique" that lets you "look" at an object as being more than one type of thing. For instance:

A student object is also a person object. If you "look" (ie cast) at the student, you can probably ask for the student ID. You can't always do that with a person, right? (a person is not necessarily a student, thus might not have a student ID). However, a person probably has a name. A student does too.

Bottom line, "looking" at the same object from different "angles" can give you different "perspectives" (ie different properties or methods)

So this technique lets you build stuff that can be "looked" at from different angles.

Why do we use polymorphism? For starters ... abstraction. At this point it should be enough info :)

Pressey answered 23/6, 2009 at 8:52 Comment(0)

In object-oriented programming, polymorphism refers to a programming language's ability to process objects differently depending on their data type or class. More specifically, it is the ability to redefine methods for derived classes.

Violette answered 2/3, 2013 at 16:45 Comment(0)

Let's use an analogy. For a given musical script every musician which plays it gives her own touch in the interpretation.

Musician can be abstracted with interfaces, genre to which musician belongs can be an abstrac class which defines some global rules of interpretation and every musician who plays can be modeled with a concrete class.

If you are a listener of the musical work, you have a reference to the script e.g. Bach's 'Fuga and Tocata' and every musician who performs it does it polymorphicaly in her own way.

This is just an example of a possible design (in Java):

public interface Musician {
  public void play(Work work);
}

public interface Work {
  public String getScript();
}

public class FugaAndToccata implements Work {
  public String getScript() {
    return Bach.getFugaAndToccataScript();
  }
}

public class AnnHalloway implements Musician {
  public void play(Work work) {
    // plays in her own style, strict, disciplined
    String script = work.getScript()
  }
}

public class VictorBorga implements Musician {
  public void play(Work work) {
    // goofing while playing with superb style
    String script = work.getScript()
  }
}

public class Listener {
  public void main(String[] args) {
    Musician musician;
    if (args!=null && args.length > 0 && args[0].equals("C")) {
      musician = new AnnHalloway();
    } else {
      musician = new TerryGilliam();
    }
    musician.play(new FugaAndToccata());
}

Yazbak answered 23/6, 2009 at 8:21 Comment(1)

AnnHalloway and VictorBorga feel like they should be objects rather than classes -- your example would read better with eg. public class Pianist implements Musician and victorBorge = new Pianist(); etc. – Sorcim 11/1, 2019 at 7:26

I've provided a high-level overview of polymorphism for another question:

Polymorphism in c++

Hope it helps. An extract...

...it helps to start from a simple test for it and definition of [polymorphism]. Consider the code:

Type1 x;
Type2 y;

f(x);
f(y);

Here, f() is to perform some operation and is being given the values x and y as inputs. To be polymorphic, f() must be able to operate with values of at least two distinct types (e.g. int and double), finding and executing type-appropriate code.

( continued at Polymorphism in c++ )

Tallith answered 16/6, 2011 at 6:7 Comment(0)

Polymorphism is an ability of object which can be taken in many forms. For example in human class a man can act in many forms when we talk about relationships. EX: A man is a father to his son and he is husband to his wife and he is teacher to his students.

Feder answered 8/4, 2014 at 13:1 Comment(0)

Polymorphism is the ability of an object to take on many forms. The most common use of polymorphism in OOP occurs when a parent class reference is used to refer to a child class object. In this example that is written in Java, we have three type of vehicle. We create three different object and try to run their wheels method:

public class PolymorphismExample {

    public static abstract class Vehicle
    {
        public int wheels(){
            return 0;
        }
    }

    public static class Bike extends Vehicle
    {
        @Override
        public int wheels()
        {
            return 2;
        }
    }

    public static class Car extends Vehicle
    {
        @Override
        public int wheels()
        {
            return 4;
        }
    }

    public static class Truck extends Vehicle
    {
        @Override
        public int wheels()
        {
            return 18;
        }
    }

    public static void main(String[] args)
    {
        Vehicle bike = new Bike();
        Vehicle car = new Car();
        Vehicle truck = new Truck();

        System.out.println("Bike has "+bike.wheels()+" wheels");
        System.out.println("Car has "+car.wheels()+" wheels");
        System.out.println("Truck has "+truck.wheels()+" wheels");
    }

}

The result is:

For more information please visit https://github.com/m-vahidalizadeh/java_advanced/blob/master/src/files/PolymorphismExample.java. I hope it helps.

Marabelle answered 2/10, 2016 at 21:51 Comment(4)

Yes, but you didn't explain what are the benefits of polymorphism. There is obviously a shorter code, where you would delete the Vehicle class, and it would still work ( with a different object declaration, of course). – Strafford 13/12, 2016 at 11:0

I didn't explain, since the person who asked the question didn't ask about the benefits. He asked: "What is polymorphism, what is it for, and how is it used?". About the code, if you can do it better, please post your answer. So, our community can use it. Thanks for your comment. – Marabelle 14/12, 2016 at 3:49

Sorry, didn't want to sound rude, others didn't explain too. At least you bothered to type in the code. Anyways, he asked what is it for, but none of the examples on this page explain what is it for. You all just present a complex way to get the same results as this: s28.postimg.org/jq8vl6031/Poly.jpg and none cared to explain why would one want to do use polymorphism, what's its gain or purpose, what could have not been done if it wasn't used? All I see on this page is a proposition to climb up to your apartment using stairs, and not an elevator.. – Strafford 14/12, 2016 at 8:51

.. without noticing that one carries a flag pole that is too big to fit an elevator. I don't know how to post code, so I can't be of much help... – Strafford 14/12, 2016 at 8:52

Polymorphism is the ability of the programmer to write methods of the same name that do different things for different types of objects, depending on the needs of those objects. For example, if you were developing a class called Fraction and a class called ComplexNumber, both of these might include a method called display(), but each of them would implement that method differently. In PHP, for example, you might implement it like this:

//  Class definitions

class Fraction
{
    public $numerator;
    public $denominator;

    public function __construct($n, $d)
    {
        //  In real life, you'd do some type checking, making sure $d != 0, etc.
        $this->numerator = $n;
        $this->denominator = $d;
    }

    public function display()
    {
        echo $this->numerator . '/' . $this->denominator;
    }
}

class ComplexNumber
{
    public $real;
    public $imaginary;

    public function __construct($a, $b)
    {
        $this->real = $a;
        $this->imaginary = $b;
    }

    public function display()
    {
        echo $this->real . '+' . $this->imaginary . 'i';
    }
}


//  Main program

$fraction = new Fraction(1, 2);
$complex = new ComplexNumber(1, 2);

echo 'This is a fraction: '
$fraction->display();
echo "\n";

echo 'This is a complex number: '
$complex->display();
echo "\n";

Outputs:

This is a fraction: 1/2
This is a complex number: 1 + 2i

Some of the other answers seem to imply that polymorphism is used only in conjunction with inheritance; for example, maybe Fraction and ComplexNumber both implement an abstract class called Number that has a method display(), which Fraction and ComplexNumber are then both obligated to implement. But you don't need inheritance to take advantage of polymorphism.

At least in dynamically-typed languages like PHP (I don't know about C++ or Java), polymorphism allows the developer to call a method without necessarily knowing the type of object ahead of time, and trusting that the correct implementation of the method will be called. For example, say the user chooses the type of Number created:

$userNumberChoice = $_GET['userNumberChoice'];

switch ($userNumberChoice) {
    case 'fraction':
        $userNumber = new Fraction(1, 2);
        break;
    case 'complex':
        $userNumber = new ComplexNumber(1, 2);
        break;
}

echo "The user's number is: ";
$userNumber->display();
echo "\n";

In this case, the appropriate display() method will be called, even though the developer can't know ahead of time whether the user will choose a fraction or a complex number.

Lambency answered 23/6, 2009 at 9:10 Comment(3)

That's not polymorphism. That's two classes having methods of the same name. They would need to be linked by a base class or interface called "displayable" or something similiar, and then other methods would simply care that the object is of type "displayable" rather than Complex or Fraction. – Avidity 23/6, 2009 at 9:22

I always thought polymorphism was "two classes having methods of the same nome." In fact, to quote Stephan Kochan (from whom I'm shameless ripping off this Fraction/Complex example), "the ability to share the same method name across different classes is known as polymorphism." (from Programming_In_Objective-C) He doesn't mention any need to link classes through a base class. Maybe it's different in different languages, I honestly don't know. – Lambency 23/6, 2009 at 9:37

Even tough this defenition is quoted from a published book, I would still argue that it is incorrect. Especially since it seems to clash with every other, language agnostic defenition of polymorphism. And while the final result is the same as seen with polymorphism, I would argue that it is instead the dynamic typing that allows programmer be able to thrust that the correct implementation of a method among other, similary named methods is being called. – Ultimately 23/6, 2009 at 10:15

Polymorphism:

Different execution according to the instance of the class, not the type of reference variable.

An interface type reference variable can refer to any of the class instances that implement that interface.

Elihu answered 17/4, 2015 at 19:15 Comment(0)

Polymorphism literally means, multiple shapes. (or many form) : Object from different classes and same name method , but workflows are different. A simple example would be:

Consider a person X.

He is only one person but he acts as many. You may ask how:

He is a son to his mother. A friend to his friends. A brother to his sister.

Ironworker answered 6/5, 2015 at 7:32 Comment(0)

Polymorphism in OOP means a class could have different types, inheritance is one way of implementing polymorphism.

for example, Shape is an interface, it has Square, Circle, Diamond subtypes. now you have a Square object, you can upcasting Square to Shape automatically, because Square is a Shape. But when you try to downcasting Shape to Square, you must do explicit type casting, because you can't say Shape is Square, it could be Circle as well. so you need manually cast it with code like Square s = (Square)shape, what if the shape is Circle, you will get java.lang.ClassCastException, because Circle is not Square.

Lamella answered 6/11, 2015 at 10:57 Comment(0)

What is polymorphism?

Polymorphism is the ability to:

Invoke an operation on an instance of a specialized type by only knowing its generalized type while calling the method of the specialized type and not that of the generalized type:

This is dynamic polymorphism.
Define several methods having the save name but having differents parameters:

This is static polymorphism.

The first if the historical definition and the most important.

What is polymorphism used for?

It allows to create strongly-typed consistency of the class hierarchy and to do some magical things like managing lists of objects of differents types without knowing their types but only one of their parent type, as well as data bindings.

Strong and weak typing

Sample

Here are some Shapes like Point, Line, Rectangle and Circle having the operation Draw() taking either nothing or either a parameter to set a timeout to erase it.

public class Shape
{
 public virtual void Draw()
 {
   DoNothing();
 }
 public virtual void Draw(int timeout)
 {
   DoNothing();
 }
}

public class Point : Shape
{
 int X, Y;
 public override void Draw()
 {
   DrawThePoint();
 }
}

public class Line : Point
{
 int Xend, Yend;
 public override Draw()
 {
   DrawTheLine();
 }
}

public class Rectangle : Line
{
 public override Draw()
 {
   DrawTheRectangle();
 }
}

var shapes = new List<Shape> { new Point(0,0), new Line(0,0,10,10), new rectangle(50,50,100,100) };

foreach ( var shape in shapes )
  shape.Draw();

Here the Shape class and the Shape.Draw() methods should be marked as abstract.

They are not for to make understand.

Explaination

Without polymorphism, using abstract-virtual-override, while parsing the shapes, it is only the Spahe.Draw() method that is called as the CLR don't know what method to call. So it call the method of the type we act on, and here the type is Shape because of the list declaration. So the code do nothing at all.

With polymorphism, the CLR is able to infer the real type of the object we act on using what is called a virtual table. So it call the good method, and here calling Shape.Draw() if Shape is Point calls the Point.Draw(). So the code draws the shapes.

More readings

C# - Polymorphism (Level 1)

Polymorphism in Java (Level 2)

Polymorphism (C# Programming Guide)

Virtual method table

Tychon answered 2/10, 2019 at 8:19 Comment(0)

Polymorphism is the ability to use an object in a given class, where all components that make up the object are inherited by subclasses of the given class. This means that once this object is declared by a class, all subclasses below it (and thier subclasses, and so on until you reach the farthest/lowest subclass) inherit the object and it's components (makeup).

Do remember that each class must be saved in separate files.

The following code exemplifies Polymorphism:

The SuperClass:

public class Parent {
    //Define things that all classes share
    String maidenName;
    String familyTree;

    //Give the top class a default method
    public void speak(){
         System.out.println("We are all Parents");
    }
}

The father, a subclass:

public class Father extends Parent{
    //Can use maidenName and familyTree here
    String name="Joe";
    String called="dad";

    //Give the top class a default method
    public void speak(){
        System.out.println("I am "+name+", the father.");
    }
}

The child, another subclass:

public class Child extends Father {
    //Can use maidenName, familyTree, called and name here

    //Give the top class a default method
    public void speak(){
        System.out.println("Hi "+called+". What are we going to do today?");
    }
}

The execution method, references Parent class to start:

public class Parenting{
    public static void main(String[] args) {
        Parent parents = new Parent();
        Parent parent = new Father();
        Parent child = new Child();

        parents.speak();
        parent.speak();
        child.speak();
    }
}

Note that each class needs to be declared in separate *.java files. The code should compile. Also notice that you can continually use maidenName and familyTree farther down. That is the concept of polymorphism. The concept of inheritance is also explored here, where one class is can be used or is further defined by a subclass.

Hope this helps and makes it clear. I will post the results when I find a computer that I can use to verify the code. Thanks for the patience!

Actinopod answered 21/11, 2013 at 17:51 Comment(1)

note that every child is not a parent so this structure is wrong. The top class should be Child (if you're not just starting with "Person") which will always be true except for Adam. You could set his parent_id to null since the Creator cannot be defined with any construct of human intellect. – Marketable 9/11, 2014 at 10:13

Polymorphism allows the same routine (function, method) to act on different types.

Since many existing answers are conflating subtyping with polymorphism, here are three ways (including subtyping) to implement polymorphism.

Parameteric (generic) polymorphism allows a routine to accept one or more type parameters, in addition to normal parameters, and runs itself on those types.
Subtype polymorphism allows a routine to act on any subtype of its parameters.
Ad hoc polymorphism generally uses routine overloading to grant polymorphic behavior, but can refer to other polymorphism implementations too.

Hot tags

Godot Unity Godot Help Programming Godot 4.X GUI GDScript 3D 2D Physics CSharp Godot 3.X VR XR Projects C++

Simple Explanation by analogy

How is it actually implemented - through a base class or a common interface

Summary

Recommended topics

Hot tags