Polymorphism in object-oriented programming

In simple terms, polymorphism is the ability of one type, A, to appear as and be used like another type, B. In strongly typed languages, this usually means that type A somehow derives from type B, or type A implements an interface that represents type B.

In non-strongly typed languages (dynamically typed languages) types are implicitly polymorphic to the extent they have similar features (fields, methods, operators). In fact, this is one of the principal benefits of dynamic typing.

For example, the numerical operators +,-,/,* allow polymorphic treatment of the various numerical types Integer, UnSigned Integer, Float, Decimal, etc; each of which have different ranges, bit patterns, and representations. Another common example is the use of the "+" operator which allows similar or polymorphic treatment of numbers (addition), strings (concatination), and lists (attachment).

More precisely, polymorphism (object-oriented programming theory) is the ability of objects belonging to different types to respond to method calls of the same name, each one according to an appropriate type-specific behavior. The programmer (and the program) does not have to know the exact type of the object in advance, and so the exact behavior is determined at run time (this is called "late binding" or "dynamic binding").

The different objects involved only need to present a compatible interface to the clients (the calling routines). That is, there must be public methods with the same name and the same parameter sets in all the objects. In principle, the object types may be unrelated, but since they share a common interface, they are often implemented as subclasses of the same parent class. Though it is not required, it is understood that the different methods will also produce similar results (for example, returning values of the same type).

In practical terms, polymorphism means that if class B inherits from class A, it doesn’t have to inherit everything about class A; it can do some of the things that class A does differently. This means that the same “verb” can result in different actions as appropriate for a specific class, so controlling code can issue the same command to a series of objects and get appropriately different results from each one.

Overriding and Overloading

If a Dog is commanded to speak(), this may emit a Bark. However, if a Pig is commanded to speak(), this may emit an Oink. They both inherit speak() from Animal, but their derived class methods override the methods of the parent class; this is Overriding Polymorphism.

Overloading Polymorphism is the use of one method signature, or one operator such as "+", to perform several different functions depending on the implementation. The "+" operator, for example, may be used to perform integer addition, float addition, list concatenation, or string concatenation. Any two subclasses of Number, such as Integer and Double, are expected to add together properly in an OOP language. The language must therefore overload the concatenation operator, "+", to work this way. This helps improve code readability.

Advantages of polymorphism

Polymorphism allows client programs to be written based only on the abstract interfaces of the objects which will be manipulated (interface inheritance). This means that future extension in the form of new types of objects is easy, if the new objects conform to the original interface. In particular, with object-oriented polymorphism, the original client program does not even need to be recompiled (only relinked) in order to make use of new types exhibiting new (but interface-conformant) behavior.

In C++, for instance, this is possible because the interface definition for a class defines a memory layout, the virtual function table describing where pointers to functions can be found. Future, new classes can work with old, precompiled code because the new classes must conform to the abstract class interface, meaning that the layout of the new class's virtual function table is the same as before; the old, precompiled code can still look at the same memory offsets relative to the start of the object's memory in order to find a pointer to the new function. It is only that the new virtual function table points to a new implementation of the functions in the table, thus allowing new, interface-compliant behavior with old, precompiled code.

Since program evolution very often appears in the form of adding types of objects (i.e. classes), this ability to cope with and localize change that polymorphism allows is the key new contribution of object technology to software design.

Examples

Python

Python makes extensive use of polymorphism in its basic types. For example, strings (immutable sequences of characters) and lists (mutable sequences of elements of any type) have the same indexing interface and the same lookup interface (which call the appropriate underlying methods).myString = 'Hello, world!'myList = [0, 'one', 1, 'two', 3, 'five', 8]

print myString [:5] # prints Helloprint myList [:5] # prints [0, 'one', 1, 'two', 3]

print 'e' in myString # prints Trueprint 5 in myList # prints False

However, the most common examples of polymorphism are found in custom classes. Consider the example below, where two subclasses (Cat and Dog) are derived from an Animal superclass. Two Cat objects and one Dog are instantiated and given names, and then they are gathered in a tuple (a, b, c) and their "talk" method is called.class Animal: def __init__(self, name): # Constructor of the class self.name = name

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

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

a = Cat('Missy')b = Cat('Mr. Bojangles')c = Dog('Lassie')

for animal in (a, b, c): print animal.name + ': ' + animal.talk()

# prints the following:
#
# Missy: Meow!
# Mr. Bojangles: Meow!
# Lassie: Woof! Woof!

Note that Python makes polymorphism particularly easy to write, since the language is dynamically (and implicitly) typed: a name can be bound to objects of any type (or class) without having to explicitly specify the type, and a list holds mixed type (unlike a C array or a Java array, be it generic or not). Note the inevitable trade-off though: a language that generates fewer compile-time errors tends to generate more run-time errors, requiring explicit (unit) testing.

C++

#include
#include

using namespace std;

class Animal{ public: Animal(const string& name) : name(name) { } virtual const string talk() = 0; const string name;};

class Cat : public Animal{ public: Cat(const string& name) : Animal(name) { } virtual const string talk() { return "Meow!"; ;

class Dog : public Animal{ public: Dog(const string& name) : Animal(name) { } virtual const string talk() { return "Arf! Arf"; ;

// prints the following://// Missy: Meow!// Mr. Bojangles: Meow!// Lassie: Arf! Arf!//int main(){ Animal* animals [] = { new Cat("Missy"), new Cat("Mr. Bojangles"), new Dog("Lassie") };

for(int i = 0; i < 3; i++) cout << animals [i] ->name << ": " << animals [i] ->talk() << endl;

return 0;}

Note that the talk() method is explicitly declared as virtual. This is because polymorphic method calls have relatively high overhead in C++ [Driesen, Karel and Hölzle, Urs, [http://www.cs.ucsb.edu/~urs/oocsb/papers/oopsla96.pdf "The Direct Cost of Virtual Function Calls in C++"] , OOPSLA 1996] . This overhead is lessened by treating all method calls as non-polymorphic, unless explicitly marked as virtual by the developer.

Visual Basic .NET

One way of doing polymorphism is through the definition and implementation of a common interface. Consider the example below, where two subclasses (Cat and Dog) implement the IAnimal interface. Two Cat objects and one Dog are instantiated and given names, and then they are gathered in a list and their talk method is called.

Namespace std

Public Interface IAnimal ReadOnly Property Name() As String Function Talk() As String End Interface

Public Class Cat Implements IAnimal

Private mName As String

Sub New(ByVal name As String) mName = name End Sub

Public ReadOnly Property Name() As String Implements IAnimal.Name Get Return mName End Get End Property

Public Function Talk() As String Implements IAnimal.Talk Return "Meow!" End Function End Class

Public Class Dog Implements IAnimal

Private mName As String

Sub New(ByVal name As String) mName = name End Sub

Public ReadOnly Property Name() As String Implements IAnimal.Name Get Return mName End Get End Property

Public Function Talk() As String Implements IAnimal.Talk Return "Arf! Arf!" End Function End Class

Public Module TestAnimals

' Prints the following: ' ' Missy: Meow! ' Mr. Bojangles: Meow! ' Lassie: Arf! Arf! Public Sub Main() Dim animals(2) As IAnimal animals(0) = New Cat("Missy") animals(1) = New Cat("Mr. Bojangles") animals(2) = New Dog("Lassie")

For Each a As IAnimal In animals Console.Out.WriteLine("{0}: {1}", a.Name, a.Talk) Next a

End Sub End Module

End Namespace

Java

Java supports interfaces like .NET does, but does not have anything similar to .NET properties. Since Java interfaces require that all variables in them be class constants, an abstract class is used instead.

abstract class Animal{ public final String name; public abstract String talk();

public Animal(String name) { this.name = name;

class Cat extends Animal{ public Cat(String name) { super(name); }

public String talk() { return "Meowww!";

class Dog extends Animal{ public Dog(String name) { super(name); }

public String talk() { return "Arf! Arf!";

public class TestAnimals{ // prints the following: // // Missy: Meowww! // Mr. Bojangles: Meowww! // Lassie: Arf! Arf! // public static void main(String [] args) {

Animal [] animals = { new Cat("Missy"), new Cat("Mr. Bojangles"), new Dog("Lassie") }; for (Animal a : animals) System.out.println(a.name + ": " + a.talk());

Xbase++

#include "class.ch"

//// This program prints://// Missy Meow!// Mr. Bojangles Meow!// Lassie Bark!// Press any key to continue...//

///////////////////////////////PROCEDURE Main()///////////////////////////////

LOCAL aAnimals := Array(3) LOCAL i

aAnimals [1] := Cat():New("Missy") aAnimals [2] := Cat():New("Mr. Bojangles") aAnimals [3] := Dog():New("Lassie")

FOR i:=1 TO LEN(aAnimals) ? aAnimals [i] :Name + " " + aAnimals [i] :Talk() NEXT i

WAIT

RETURN

///////////////////////////////CLASS Animal///////////////////////////////

EXPORTED: VAR Name READONLY

METHOD Init DEFERRED CLASS METHOD TalkENDCLASS

METHOD Animal:Init( cName ) ::Name := cNameRETURN Self

///////////////////////////////CLASS Dog FROM Animal/////////////////////////////// EXPORTED: METHOD TalkENDCLASS

METHOD Dog:Talk()RETURN "Bark!"

///////////////////////////////CLASS Cat FROM Animal/////////////////////////////// EXPORTED: METHOD TalkENDCLASS

METHOD Cat:Talk()RETURN "Meow!"

Other concepts

In non-object-oriented programming languages, the term polymorphism has different, but related meanings; one of these, "parametric polymorphism", is known as generic programming in the OOP community and is supported by many languages including C++, Eiffel, and recent versions of C# and Java.

ee also

* Inheritance (computer science)
* Polymorphic association

References

External links

* [http://javalessons.com/cgi-bin/fun/java-tutorials-main.cgi?ses=ao789&code=ovd&sub=fun Java polymorphism interactive lesson]
* [http://wiki.visual-prolog.com/index.php?title=Objects_and_Polymorphism Objects and Polymorphism (Visual Prolog)]