Java Polymorphism

Java Polymorphism

The word polymorphism means having multiple forms. The term Polymorphism gets derived from the Greek word where poly + morphos where poly means many and morphos means forms.

There are two types of polymorphism

• Static Polymorphism
• Dynamic Polymorphism.

Polymorphism is another special feature of object-oriented programming (OOPs). The approach which lies beneath this concept is “single interface with multiple implementations.” This offers a single interface for controlling access to a general class of actions.

Polymorphism can be achieved in two of the following ways:

• Method Overloading(Compile time Polymorphism)
• Method Overriding(Run time Polymorphism)

• Static Polymorphism is in other words termed as compile-time binding or early binding.
• Static binding occurs at compile time. Method overloading is a case of static binding and in this case binding of method call to its definition happens at the time of compilation.

Method Overloading

• To call an overloaded method in Java, it is must use the type and/or the number of arguments to determine which version of the overloaded method to actually call.
• The overloaded methods may have varied return types and the return type single-handedly is insufficient to make out two versions of a method.
• As and when Java compiler encounters a call to an overloaded method, it simply executes the version of the method whose parameters match the arguments used in the call.
• It permits the user to obtain compile time polymorphism with name method name.
• An overloaded method is able to throw different kinds of exceptions.
• A method which is overloaded can contain different access modifiers.

Variations in Overloading a Method

Overloading method’s argument lists might differ in:

• Number of parameters passed
• Data type of actual parameters
• Sequence of data type of actual parameters

Program for Method Overloading in Java

Example:

class Mltply {
 void mul(int a, int b) {
  System.out.println("Sum of two=" + (a * b));
 }

 void mul(int a, int b, int c) {
  System.out.println("Sum of three=" + (a * b * c));
 }
}
class Polymorphism {
 public static void main(String args[]) {
  Mltply m = new Mltply();
  m.mul(6, 10);
  m.mul(10, 6, 5);
 }
}

Method Overriding

Rules of method overriding in Java

• Argument list: The argument list at the time of overriding method need to be same as that of the method of the parent class. The data types of the arguments along with their sequence must have to be preserved as it is in the overriding method.
• Access Modifier: The Access Modifier present in the overriding method (method of subclass) cannot be more restrictive than that of an overridden method of the parent class.
• The private, static and final methods can’t be overridden as they are local to the class.
• Any method which is overriding is able to throw any unchecked exceptions, in spite of whether the overridden method usually method of parent class might throw an exception or not.

Program for Method Overriding in Java

Example:

class parent {
 public void work() {
  System.out.println("Parent is under retirement from work.");
 }
}
class child extends parent {
 public void work() {
  System.out.println("Child has a job");
  System.out.println(" He is doing it well");
 }
 public static void main(String argu[]) {
  child c1 = new child();
  c1.work();
 }
}

Advantage of method overriding

One major advantage of method overriding is that a class can give its own specific execution to an inherited method without having the modification in the parent class (base class).

---