What is Polymorphism? Describe briefly with example.  

Polymorphism (from the Greek, meaning “many forms”) is a feature that allows one interface to be used for a general class of actions. The specific action is determined by the exact nature of the situation. More generally, the concept of polymorphism is often expressed by the phrase “one interface, multiple methods.” This means that it is possible to design a generic interface to a group of related activities. This helps reduce complexity by allowing the same interface to be used to specify a general class of action. Consider a stack (which is a last-in, first-out list). You might have a program that requires three types of stacks. One stack is used for integer values, one for floating-point values, and one for characters. The algorithm that implements each stack is the same, even though the data being stored differs. In a non–object-oriented language, you would be required to create three different sets of stack routines, with each set using different names. However, because of polymorphism, you can specify a general set of stack routines that all share the same names.

Answered by saixaero at 3:26 PM on November 11, 2007

Polymorphism is often considered the most powerful feature of object-oriented programming. Greek for “many forms,” polymorphism is the ability to hide alternative implementations behind a common interface. This concept leverages inheritance and encapsulation among other OO concepts. Polymorphism is the ability for objects of different types to respond to messages of the same type. The concept behind polymorphism is that a function or data type can be written in a generic way, so that it can handle any interactions to it regardless of the acting object’s type. Using the abstract interfaces of objects, polymorphism can be used to create extensible and loosely-coupled programs. The benefit of this is that if new types are added, and they adhere to the common interface specified, then their impact on changing the system will be minimal. When using inheritance based polymorphism, a class can be used as more than one type (MS Polymorphism, 2006). It can be used as its own type, any base types, or any interface type that implements its interface. In C#, every type is polymorphic. Types can be used as their own type, or as an object instance, since object is the base class of all types (MS Polymorphism, 2006). The following scenario helps explain polymorphism. Let us assume two classes for now, class A and class B. Class A is our base class. With inheritance we know that any class that inherits from class A will inherit all of class A’s methods, fields, properties, and events. In the example below, when class B derives from A, it can choose to override the base class’s functionality. Example 1 public class A { public virtual void DoSomething() {} public virtual int SomeValue { Get { return 0; } } } public class B : A { public override void DoSomething() {} public override int SomeValue { get { return 0; } } } B b = new B(); b.DoSomething(); // calls the override method in class B Now, let’s create an instance of class A, casting our class B instance to it. A a = (A)b; // create an instance of A casting our instance of B a.DoSomething(); // calls the override method in class B In Example 1, an instance of class A is created using the instance of object B. If this is confusing, then think of it as if class A were created using “A a = new B();” The object instance of class A is now using an object of the derived class B that has been cast to the base class type A. What does this mean? Well, think of it as though Class B is now being represented by a more generic object, class A.

Answered by @ at 2:52 PM on November 11, 2007

"Poly" means "many" and "morph" means "form". Polymorphism is the ability of an object (or reference) to assume (be replaced by) or become many different forms of object. Example: function overloading, function overriding, virtual functions. Another example can be a plus ‘+’ sign, used for adding two integers or for using it to concatenate two strings. In object-oriented programming, polymorphism (from the Greek meaning "having multiple forms") is the characteristic of being able to assign a different meaning or usage to something in different contexts - specifically, to allow an entity such as a variable, a function, or an object to have more than one form. There are several different kinds of polymorphism. 1) A variable with a given name may be allowed to have different forms and the program can determine which form of the variable to use at the time of execution. For example, a variable named USERID may be capable of being either an integer (whole number) or a string of characters (perhaps because the programmer wants to allow a user to enter a user ID as either an employee number - an integer - or with a name - a string of characters). By giving the program a way to distinguish which form is being handled in each case, either kind can be recognized and handled. 2) A named function can also vary depending on the parameters it is given. For example, if given a variable that is an integer, the function chosen would be to seek a match against a list of employee numbers; if the variable were a string, it would seek a match against a list of names. In either case, both functions would be known in the program by the same name. This type of polymorphism is sometimes known as overloading. In C++, for example, the operator known as the plus sign (+) - which is effectively a simple named function - can be assigned to operate on two objects such that it adds them together (perhaps the most common form of the + operation) or, as in Boolean searching, a + can indicate a logical "and" (meaning that both words separated by the + operator must be present in order for a citation to be returned). In another context, the + sign could mean an operation to concatenate the two objects or strings of letters on either side of the + sign. A given operator can also be given yet another meaning when combined with another operator. For example, in the C++ language, a "++" following a variable can mean "increment this value by 1". The meaning of a particular operator is defined as part of a class definition. Since the programmer can create classes, the programmer can also define how operators work for this class of objects; in effect, the programmer can redefine the computing language. 3) Polymorphism can mean, as in the ML language, a data type of "any," such that when specified for a list, a list containing any data types can be processed by a function. (For example, if a function simply determines the length of a list, it doesn't matter what data types are in the list.) March 27, 2005 10:19:42 #1 Zaid Member Since: Visitor Total Comments: N/A ------------------------------- ----------------------------------- -------------- RE: What is polymorphism? Explain with an example? --------------------------------- ----------------------------------- ------------ An example would be: A "vehicle" class can be a part of a inheritance heirachy where derived classes are "sedan" and "SUV". Derived from "sedan" could be "Corolla", and derived from "SUV" could be "Pathfinder". CAR / SUV SEDAN / PATHFINDER COROLLA Now, using such an example, it is true that any object below in a heirarchy is also something that is directly up in the heirarchy. Hence, Pathfinder "is a" SUV, and SUV "is a" CAR. Also, Pathfinder "is a" CAR. Hence, using pointers of Base classes (higher in an inheritance heirarchy) can be assigned to objects of derived classes and can be used in a unified manner with the use of

Answered by Urexpert at 2:43 PM on November 11, 2007

In simple terms, polymorphism lets you treat derived class members just like their parent class's members. More precisely, polymorphism (object-oriented programming theory) is the ability of objects belonging to different types to respond to method calls of methods 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, so this behavior can be implemented 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. Examples 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). source lang=python myString = 'Hello world' myList = [0, 'one', 1, 'two', 3, 'five', 8] print myString[:5] # prints Hello print myList[:5] # prints [0, 'one', 1, 'two', 3] print 'e' in myString # prints True print 5 in myList # prints False /source 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 list ([a, b, c]) and their talk method is called. source lang=python class Animal: def __init__(self, name): self.name = name class Cat(Animal): def talk(self): return 'Meow!' class Dog(Animal): def talk(self): return 'Arf! Arf!' a = Cat('Missy') b = Cat('Mr. Bojangles') c = Dog('Lassie') for animal in [a, b, c]: print animal.name + ': ' + animal.talk() 1. prints the following: 2. Missy: Meow! 3. Mr. Bojangles: Meow! 4. Lassie: Arf! Arf! /source

Answered by alokgupta14 at 2:35 PM on November 11, 2007