Polymorphism

The term polymorphism can be defined as “having many forms.” A polymorphic reference is a reference variable that can refer to different types of objects at different points in time. The specific method invoked through a polymorphic reference can change from one invocation to the next.

Polymorphism in programming is a concept that's a bit like having a universal remote control. Just as this one remote can interact with your TV, sound system, and DVD player in different ways, polymorphism allows a single interface to be used with different underlying forms (data types).

Here's how it works in simple terms:

Many Forms: The word "polymorphism" comes from Greek words meaning "many forms." In programming, it refers to the ability of a single function or method to work in different ways depending on the object it is acting upon.
Example - Shapes: Imagine you have a program with different shapes (like circles, squares, triangles). All of these shapes might have a method called draw, but the way you draw each shape is different. Polymorphism allows you to call the draw method on any shape without needing to know the specific type of shape. The correct draw method is called depending on whether it's a circle, a square, or a triangle.
Types:
- Compile-Time Polymorphism (Method Overloading): This is like having multiple versions of the same remote button, each doing something a bit different depending on what you're trying to control (TV, DVD player, etc.). In programming, this means having multiple methods with the same name but different parameters.
- Run-Time Polymorphism (Method Overriding): This is like the remote automatically adjusting its function based on the device it's pointing at. In programming, this is when a subclass overrides a method of its superclass, and the method to execute is determined at runtime.
Why Use Polymorphism? It makes the program more flexible and scalable. Just like the universal remote simplifies controlling different devices, polymorphism simplifies and unifies the interaction with different objects in a program.

In summary, polymorphism in programming allows methods to do different things based on the object they are acting upon, much like a universal remote control can operate different devices in ways specific to each device. This leads to more flexible and easily maintainable code.

Polymorphism is a fundamental concept in programming, particularly within the paradigm of object-oriented programming (OOP). It describes the ability of different objects to be accessed through the same interface, allowing for different underlying forms (data types) to be manipulated in a uniform manner.

Conceptual Overview:

Polymorphism comes from Greek words meaning "many forms."
It allows objects of different classes to be treated as objects of a common superclass.
The specific form or class of an object is less important than the fact that it has the interface expected; the details of its actual type can remain hidden.

Types of Polymorphism:

Ad-hoc Polymorphism: This is achieved through function overloading or operator overloading.
Parametric Polymorphism: This allows a function or a data type to be written generically, so it can handle values identically without depending on their type. This is often used in generic programming.
Subtype Polymorphism (or Inclusion Polymorphism): This is the form most commonly referred to as "polymorphism" in OOP. It allows a function to use objects of different types at different times, depending on the type of the object it is referencing at that time.

Practical Example:

Consider a simple class hierarchy where a superclass Shape has a method draw(). Subclasses like Circle, Square, and Triangle each implement draw() differently. If you have a list of Shape objects, you can iterate over them and call draw() on each one, and the correct version of the method is called for each object, whether it's a Circle, Square, or Triangle.

Real-world Analogy

Imagine a simple video game with different types of characters like warriors, archers, and mages. Each character type has a unique way of attacking: warriors might use swords, archers use bows and arrows, and mages use magic spells. However, from the game's perspective, they are all game characters and can perform an "attack" action.

Here, polymorphism allows you to treat all these different character types as general "game characters" and call the "attack" action on them, without needing to know their specific types. The appropriate attack action (sword slash, arrow shot, or magic spell) will be carried out based on the actual type of character, even though your code simply calls the same "attack" method on a general "game character."

Benefits

Code Reusability: You can write code that works on the superclass type, but it will work with any subclass type, providing they follow the expected contract (like method names and parameters).
Code Maintainability: Polymorphism promotes cleaner, more intuitive, and more maintainable code. You can add new subclasses with little or no modification to existing code that uses the superclass.
Flexibility: Polymorphism allows for code that is more flexible and can handle a range of inputs, reducing the complexity of conditional statements.
Abstraction: It allows for abstract design, where you can define a common class for a group of related classes.

By understanding and using polymorphism, you can write more flexible, maintainable, and reusable code.

At some point, the commitment is made to execute certain code to carry out a method invocation. This commitment is referred to as binding a method invocation to a method definition. In many situations, the binding of a method invocation to a method definition can occur at compile time. For polymorphic references, however, the decision cannot be made until run time. The method definition that is used is based on the object that is being referred to by the reference variable at that moment. This deferred commitment is called late binding or dynamic binding. It is less efficient than binding at compile time, because the decision must be made during the execution of the program. This overhead is generally acceptable in light of the flexibility that a polymorphic reference provides.

Example

/* 
 * Polymorphism  Late binding 
 */

// Animal class - this is the base class 
 class Animal {	 
  public void animalSound()
  {
	  System.out.println("The animal makes a sound");
  } 
   
  // Regular method
  public void sleep() {
    System.out.println("Zzz");
  }
} //end of Animal Base Class
 
 /* *********************************
  * Derived Classes
  *********************************** */

//Subclass (inherit from Animal)
//Notice how we define the Abstract method animalSound declared in the super class 
class Cat extends Animal {
	public void animalSound() {
	// The body of animalSound() is provided here
	System.out.println("The cat says Meow");
	}
} //end of Cat Class

//Subclass (inherit from Animal)
class Dog extends Animal {
	public void animalSound() {
	// The body of animalSound() is provided here
	System.out.println("The dog says Woof");
	}
} //end of Dog class

//Subclass (inherit from Animal)
class Cow extends Animal {
	public void animalSound() {
	// The body of animalSound() is provided here
	System.out.println("The dog says Moo");
	}
} 


/*
 * ******************************
 * Main Program to demo polymorphism
 * ******************************
 */

public class Demo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		 Animal myAnimal = new Animal();  // Create a Animal object
		 myAnimal.animalSound();
		 myAnimal.sleep();
		 
		 //now create an Animal and make it a Dog
		 Animal myDog = new Dog();
		 myDog.animalSound();
		 myDog.sleep();
		 
		 //now create an Animal and make it a Cat
		 Animal myCat = new Cat();
		 myCat.animalSound();
		 myCat.sleep();
		 
		 Animal myCow = new Cow();
		 myCow.animalSound();
		 myCow.sleep();
		 
		 //demonstration of instanceof
		 if(myCat instanceof Cat)
		 {
			 System.out.println("This is a cat!");
		 }
		 if(myCat instanceof Animal)
		 {
			 System.out.println("This is a Animal!");
		 }

	}

}

The given Java code is a demonstration of polymorphism in Java using animal sounds as examples. Polymorphism allows objects 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.

Let's go through the important parts:

The Animal class is the parent (base) class with two methods: animalSound() and sleep(). animalSound() is overridden in each of the child classes while sleep() is not, meaning it's the same across all animal types.
Cat, Dog, and Cow are subclasses that each extend Animal. They each override the animalSound() method to print out a unique sound for that animal. This is a perfect example of method overriding in Java, which is one of the ways we can achieve polymorphism.
In the main method, we first create a generic Animal object and call its methods. This is standard object-oriented programming.
Then we create Dog, Cat, and Cow objects but refer to them with Animal references. This is polymorphism in action - we can call the animalSound() method on these references and it will call the overridden method in the respective subclass, even though the reference type is Animal. This is known as late binding or dynamic method dispatch.
The sleep() method is also called on these references. Since sleep() is not overridden in the subclasses, the original sleep() method from Animal class is called.
Finally, the instanceof keyword is used to check if myCat is an instance of Cat and Animal. instanceof returns true if the object being compared is an instance of the specified type or an instance of a subclass of the specified type. So, in this case, both checks will return true because myCat is a Cat object and Cat is a subclass of Animal. This is why "This is a cat!" and "This is a Animal!" both get printed.