Method Overloading in Java

Features/advantage of Method Overloading

• Static Polymorphism : Method overloading use static polymorphism, where the binding of methods occurs during the compilation process. This eliminates the need for additional processes like binding and checking at runtime.
• Efficiency : Using method overloading, the binding of methods is done at compile-time, It help in improving performance as compared to dynamic polymorphism. This make code execution faster.
• Improved Readability : By using method overloading, developers can provide multiple methods with the same name but different parameter lists. This makes the code more readable and natural as the method names can reflect the functionality they perform.
• Flexibility : Method overloading allows flexibility in parameter handling. Developers can define multiple methods with the same name but different types, numbers, or sequences of parameters. This enables the code to handle different scenarios or input variations. This eliminates need for separate method names.
• Code Reusability : Method overloading promotes code reusability by allowing developers to use the same method name for similar operations. This reduces code duplication and improves maintainability.
• Enhanced Error Handling : Method overloading helps in catching ambiguity errors. When the return value of a method is changed slightly, method overloading detects the ambiguity and raises an error, making it easier to identify and resolve such issues.

Method overloading example

 // Method overloading example  

class Product {
    int Multiply(int p, int q){  
     return p * q;
  }

  float Multiply(float p, float q,float r){   
	  return p * q * r;
  }
}
class Overloading {
 public static void main(String[] args){
    Product product=new Product();
     System.out.println(product.Multiply(2, 4));
     System.out.println(product.Multiply(5.2f, 6.3f,2.3f));
 }
}

8 

75.34799 

Method Overriding in java

In method overriding, methods with the same name and parameters are present in both the superclass and the subclass. Based on the object used to call the method, JVM invokes the appropriate procedure. The return types for overriding should also be the same.

Features/advantage of Method Overriding

• Method overriding simplifies the process of writing generic code by allowing the child class to redefine and customize the implementation of a method inherited from the parent class.
• The super keyword can be used to call the overridden methods of the parent class and it provides multiple implementations of the same method.
• Using method overridding, a class's behavior is specified.

Java method overridden example

 // Java method overridden example  

class Animal {
    void Move(){
        System.out.println("Animals is Moving");
    }
    void Eat(){
        System.out.println("Animals is Eating");
    }
}
  
class Dog extends Animal {
    @Override
    void Move(){ // here overriding take place
        System.out.println("Dog is Moving");
    }
    @Override
    void Eat(){
        System.out.println("Dog is Eating");
    }
}
class DockerTpoint {
    public static void main(String[] args)
    {
    	Animal animal = new Animal(); // If a Animal type reference refers to a Animal object, then Animal
    	animal.Move();        // move or eat is called
    	animal.Eat();
    	
    	Animal animal2 = new Dog(); // If a Animal type reference refers
        animal2.Move();// to a Dog (Child) object Dog's eat() & Move(), 
        animal2.Eat(); // then it is called. This is called RUN TIME POLYMORPHISM. 
    }
}

Animals is Moving 

Animals is Eating 

Dog is Moving 

Dog is Eating 

Comparison Chart

Difference Between Method Overloading and Method Overriding are mention below

The Key Distinctions Between Method Overloading and Method Overriding