Defining methods with the same name within the same class, but have a different number of parameters or same parameter with different datatypes are known as method overloading

Java uses the following aspects in order to call the correct method:-
1) Number of Arguments
2) Same Argument with different datatypes

However, the return type of a method isn’t sufficient to distinguish it from other versions. As a result, method overloading cannot be implemented using only the return type.

Program to demonstrate the working of method overloading 

class showoverload{

void display(int x)
{
System.out.println("Hey I am display method with a single argument with integer type num = "+x);

}
void display(int x,int y)
{
System.out.println("Hey I am display method with a two argument of integer types num = "+x+", "+y);

}
void display(char c)
{
System.out.println("Hey I am display method with two argument of character type = "+c);

}
void display()
{
System.out.println("Hey I am display method with a no argument");

}

}
public class Overloading {

public static void main(String[] args) {
showoverload obj = new showoverload();
obj.display(10);
obj.display();
obj.display('S');
obj.display(10,20);
}

}

Output:

Method Overriding

When there is a method in subclass having the same name and type signature similar to its parent class with a specific implementation, it is said to be method overriding. Further, when an overridden method is called from the subclass, then Java always refers to subclass’s method, instead of its parent class’s method

Program to demonstrate the working of method overriding

class a{
void display()
{
System.out.println("Hi I m parent class");

}
}

class b extends a{
@Override
void display()
{
System.out.println("Subclass is being called");
}
}
public class overrideMe{

public static void main(String[] args) {
b obj = new b();
obj.display();
}

}

Output:

Polymorphism: It refers to ability to take multiple forms. In Java, method overloading and overriding are the ways to implement polymorphism.

Method Overloading

Overloading is a feature that allows a class to have multiple methods having same name. In order to achieve this, one can change number of method arguments or argument datatypes.

Syntax:

class A {
void show () {
// body
}

// overloading 

void show (int x) {

// body
}
...

}

Method Overriding

Overriding is a feature that allows a subclass to have a method that is already defined in parent class, with same name and signature, but different implementation.

Syntax:

class A {
void show () {
// body
}
}

class B extends A {

// overriding

@override
void show () {

// body
}
...

}

Difference between method overloading and overriding in Java in tabular form

[wpsm_comparison_table id=”22″ class=”center-table-align”]

Java Overriding Example:

public class PUBG {

    void demageAWM (){

        System.out.println("1 shot damage 100 % ");
    }

}

class PUBGUpdatedVersion extends PUBG {
// overriding demageAWM()
    @Override
    void demageAWM() {
        System.out.println("1 shot damage 95%");
    }
}

class test {

    public static void main(String[] args) {
        PUBGUpdatedVersion gun = new PUBGUpdatedVersion();
        gun.demageAWM();
    }
}

Output:

1 shot damage 95%

Java Overloading Example

public class PUBG {
// overloading attachments()
    void attachments (String scope){

        System.out.println("This is pistal with "+scope);
    }

    void attachments (String scope, String mag,String extender){

        System.out.println("This is Auto Gun with "+scope+","+mag+", "+extender);
    }

}


class test {

    public static void main(String[] args) {
        PUBG gun = new PUBG();
        gun.attachments("Red dot");
        gun.attachments("6x","AWM mag","AWM extender");
    }
}

Output:

This is pistal with Red dot
This is Auto Gun with 6x,AWM mag, AWM extender