Difference Between Constructor Overloading and Method Overloading in Java

Overloading methods and constructors are two popular ways to do this. We will examine each in detail in this post, including comprehensive code examples and explanations.

Constructor Overloading

In Java, constructor overloading refers to the definition of many constructors with various argument lists inside a class. With this, you may use different initialization choices for class objects based on the inputs sent in.

Rectangle.java

public class Square {
    private int length;
    private int breadth;
    // default constructor
    public Square() {
        this(0, 0); //  parameterized constructor with default values
    }
    // Parameterized constructor
    public Square(int length, int breadth) {
        this.length = length;
        this.breadth = breadth;
    }
    // Parameterized constructor
    public Square(int side) {
        this(side, side); 
    }
    public int getLength() {
        return length;
    }
    public int getBreadth() {
        return breadth;
    }
    public int getArea() {
        return length * breadth;
    }
    public static void main(String[] args) {
        Square r1 = new Square(); 
        System.out.println("Square 1 - Length: " + r1.getLength() + ", Breadth: " + r1.getBreadth());
        Square r2 = new Square(4, 5); 
        System.out.println("Square 2 - Length: " + r2.getLength() + ", Breadth: " + r2. getBreadth ());
    }
}

Output:

Square 1 - Length: 0, Width: 0
Square 2 - Length: 4, Width: 5

Explanation

Three constructors for the Rectangle class have been added to the code above: A default constructor with no arguments that calls the parameterized constructor with default values to set the length and width to 0. A parameterized constructor that takes two parameters and lets the user pass in the length and width.

Another one-argument parameterized constructor that makes it easier to create square rectangles by setting the width and length to the same value.

Method Overloading

In Java, method overloading refers to the definition of numerous methods with distinct argument lists under the same class name. The type or quantity of parameters passed to the method when calling it influences which method the compiler calls.

MathOperations.java

public class MethodOverloading {
    public int adding(int a, int b) {
        return a + b;
    }
    public double adding(double x, double y) {
        return x + y;
    }
    public String adding(String s1, String s2) {
        return s1 + s2;
    }
    public static void main(String[] args) {
        MethodOverloading o1 = new MethodOverloading ();
        int r1 = o1.adding(2, 3); 
        System.out.println("Value 1: " + r1);
        double r2 = o1.adding(0.2, 3.0); 
        System.out.println("Value 2: " + r2);
        String r3 = o1.adding("Hello, ", "Everyone");
        System.out.println("Value 3: " + r3);
    }
}

Output:

Result 1: 5
Result 2: 3.2
Result 3: Hello, Everyone

Constructor Overloading Vs. Method Overloading

Aspect	Constructor Overloading	Method Overloading
Method/Constructor Name	The constructors and the class share the same name.	Within a class, methods share the same name.
Return Type	A return type is absent from constructors.	A return type is given for methods.
Invocation	Constructors are triggered when an object is formed using the new keyword.	The names of the methods are used to explicitly call them.
Purpose	used to provide several methods for creating objects and to initialize object characteristics.	used to give users several options for carrying out the same action on items.
Parameter List	Different argument lists in constructors are involved in constructor overloading.	Different parameter lists are used in methods when method overloading occurs.
Inheritance	Although subclasses cannot inherit constructors, they can be invoked by using the super keyword.	Subclasses inherit overloading methods, which can be overridden in child classes.
Default Constructor	In the event that a class lacks defined constructors, the compiler offers a default constructor that takes no inputs.	The compiler doesn't offer a default method if a class has no declared constructors.
Use Cases	Constructor overloading is mostly utilized for initializing objects and offering many approaches to building class objects.	Multiple ways to execute an action on objects of a class are provided via method overloading.

Conclusion

Java allows for greater code reuse and flexibility in object generation and method invocation through the use of constructor overloading and method overloading. Method overloading deals with giving several methods to conduct actions on objects, whereas constructor overloading deals with object creation.

Next TopicDifference Between for loop and for-each Loop in Java

← prev next →