Why does polymorphism work

Flow Control in Java. Loops in Java. Jump Statements in Java. Arrays in Java. Strings in Java. OOPS in Java. Constructors in Java. Interfaces in Java. Keywords in Java. Exception Handling in Java. Collection Framework.

Multi-threading in Java. Table of Contents. Save Article. Improve Article. Like Article. There are two types of classes. One is the Parent or base class, and the other is the child class which can inherit the properties of the parent class.

Inheritance is a major pillar in Object-Oriented programming. It is the mechanism by which classes in Java, Python, and other OOP languages inherits the attribute of other classes. A parent class can share its attributes with a child class. An example of a parent class implementation is in DDL Dynamic-link library. A DDL can contain different classes that can be used by other programs and functions. A real-world example of inheritance is a mother and child.

The child may inherit attributes such as height, Voice patters, color. The mother can reproduce other children with the same attributes as well. You can also extend this class by inheriting it and writing few more codes to it that would instruct a robot to move and also run in some specific circumstances using if and else statement.

In summary, Inheritance is concerned with the relationship between classes and method, which is like a parent and a child. A child can be born with some of the attributes of the parents. Inheritance ensures reusability of codes just the way multiple children can inherit the attributes of their parents.

When we want to create a function, method, or class, we look for a superclass that contains the code or some of the code we want to implement. We can then derive our class from the existing one. This is a programming style where implementation details are hidden. It reduces software development complexity greatly. With Encapsulation, only methods are exposed. The programmer does not have to worry about implementation details but is only concerned with the operations.

For example, if a developer wants to use a dynamic link library to display date and time, he does not have to worry about the codes in the date and time class rather he would simply use the data and time class by using public variables to call it up.

In essence encapsulation is achieved in Python and Java by creating Private variables to define hidden classes in and then using public variables to call them up for use. With this approach, a class can be updated or maintained without worrying about the methods using them.

Once the class is changed, it automatically updates the methods accordingly. Encapsulation also ensures that your data is hidden from external modification.

Encapsulation is also known as Data-Hidden. Encapsulation can be viewed as a shield that protects data from getting accessed by outside code. Polymorphism describes a pattern in object oriented programming in which classes have different functionality while sharing a common interface. A real world analogy for polymorphism is a button. Everyone knows how to use a button: you simply apply pressure to it. 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. To understand it better and in a simple manner I used above example.. If you need reference for code follow above answers.

The president is not an expert in zinc coating, or quantum physics. He doesn't know many things. But he does know how to run the country. This makes it easier to maintain code, especially if when you are making changes. Changes are inevitable.

When things do change, you do not want to break other parts of your application. Presidents should stick to running the country, rather than getting into the nitty-gritty of specialist areas:. If the president were to specifically tell people what to do, that would mean that the president needs to know exactly what to do.

If the president needs to know specific things himself, that means that when you need to make a change, then you'll need to make it in two places , not just one. Changing code in two places rather than one can be dangerous - because it's much harder to maintain. There is a better approach: the president does not need to know the specifics of anything - he can demand the best advice, from people specifically tasked with doing those things.

All the president does is ask people to advise him - and that's what he actually does in real life - and that's what a good president should do. He's got hundreds of people streaming into his office. It doesn't actually matter who they are. All the president knows is that when he asks them to "Advise" they know how to respond accordingly :.

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 this: "Advise ".

In the above scenario, the president is doing all the work: he knows about increasing troop numbers and pre-existing conditions. This means that if middle eastern 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.

He doesn't need to know about the details. 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. 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. 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:. 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. Method names are also protected. 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. Example Polymorphism is implemented in Java using method overloading and method overriding concepts. Let us Consider Car example for discussing the polymorphism. But each have their own advanced features and more advanced technology involved in their move behavior.

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. 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. 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. 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:. This aids in generality because you don't have to provide a specific measure instance per each cup type. I know this is an older question with a lot of good answers but I'd like to include a one sentence answer:.

There are plenty of examples above that show this in action, but I feel this is a good concise answer. I was browsing another article on something entirely different..

Now I thought that I knew what Polymorphism was Wanted to write it down somewhere.. That's a geeky way of saying that different nouns can have the same verb applied to them. 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. 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. 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? 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. Why do we use polymorphism? For starters At this point it should be enough info :.

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. Bach's 'Fuga and Tocata' and every musician who performs it does it polymorphicaly in her own way.

Consider the code:. 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. 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.

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.

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:. I hope it helps. 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:. 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. For example, say the user chooses the type of Number created:. 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.

Polymorphism literally means, multiple shapes.