Polymorphism in object-oriented programming

related topics
{math, number, function}
{system, computer, user}
{work, book, publish}
{specie, animal, plant}
{school, student, university}

Subtype polymorphism, almost universally called just polymorphism in the context of object-oriented programming, is the ability of one type, A, to appear as and be used like another type, B. This article is an accessible introduction to the topic, which restricts attention to the object-oriented paradigm. The purpose of polymorphism is to implement a style of programming called message-passing in the literature[citation needed], in which objects of various types define a common interface of operations for users.

In strongly typed languages, polymorphism usually means that type A somehow derives from type B, or type C implements an interface that represents type B. In weakly typed languages types are implicitly polymorphic.

Operator overloading of the numeric operators (+, -, *, and /) allows 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 (concatenation), and lists (attachment). This is a lesser used feature of polymorphism.

The primary usage of polymorphism in industry (object-oriented programming theory) is the ability of objects belonging to different types to respond to method, field, or property 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' (calling routines). That is, there must be public or internal methods, fields, events, and properties with the same name and the same parameter sets in all the superclasses, subclasses and interfaces. In principle, the object types may be unrelated, but since they share a common interface, they are often implemented as subclasses of the same superclass. 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).

Polymorphism is not the same as method overloading or method overriding.[1] Polymorphism is only concerned with the application of specific implementations to an interface or a more generic base class. Method overloading refers to methods that have the same name but different signatures inside the same class. Method overriding is where a subclass replaces the implementation of one or more of its parent's methods. Neither method overloading nor method overriding are by themselves implementations of polymorphism.[2]

Full article ▸

related documents
Additive category
Hausdorff space
Binary heap
Planar graph
Binary tree
Spectral theorem
Euler–Maclaurin formula
Bubble sort
Transcendental number
Inequality
Partial derivative
Self-organizing map
Total order
Analytic continuation
Universal property
Linear map
Array
Octonion
Embedding
Orthogonality
Burnside's problem
Euler–Mascheroni constant
Horner scheme
Splay tree
Axiom schema of specification
Uniform convergence
NP-complete
Projective plane
Sufficiency (statistics)
Convergence of random variables