What is overloading in Java?

java

I don't understand the overloading in Java. Is there a relation with polymorphism ? It seems very abstract for me. I come more from Javascript language ? Would this apply so in Javascript ?

Overloading means that the same method name can be defined with more than one signature — the list of formal parameters (and their types).

Overloading means different things in different languages. Java is strongly typed (some might say "fiercely typed" in fact). It just means that there can be different versions of a function and the compiler can tell which one is intended by looking at the types of parameters in a call to the function (method).

JavaScript is not like that; the formal parameters to a function are just references by name in the function body, but otherwise there's nothing special about them and any function can be called with any arguments and any number of them.

Some languages use "overloading" as a runtime concept. In Erlang, it's not the types of arguments that matter when picking from several alternative versions of a function; it's the values.

edit — @MarkoTopolnik points out that the issue isn't so much about the "strength" (or "ferocity" :-) of the type system, but about how static it is. Java insists on types being explicitly declared pretty much everywhere, while JavaScript (excepting some of the new typed array constructs) doesn't.

Overloading is feature that allows having 2 methods with the same name and different signature in one class, e.g.

public void foo();
public void foo(int i);

Now you can call method foo() without arguments or with one int argument and different methods will be executed.

You are probably confused with overloading and overriding. Overriding indeed relate to polimorphysm. This is ability to overrride (change) functionality of base class into subclass. For example if Child extends Base and both have method foo() the foo() of child overrides implementation of Base. Similar feature indeed exists in JavaScript.

if you have following method in your class

public void calculate() {}

Following are some overloaded versions of it.(Note same name)

public void calculate(int i) {}
public void calculate(int i, int j) {}

But following is not an overloaded one of above method. This method differs from the original method only just because the return type. Methods with same signature but with different return types are not allowed in java.

public int calculate(int i) {}

The method which have same name with multiple definition is known as overloading

may be its differ from argument type and number of arguments.

Example

import java.io.*;
class demoOverloading
{
    int add(int x,int y) //method definition
    {
        return (x+y);
    }
    double add(double x,double y) //method definition
    {
        return (x+y);
    }
}
public class JavaApplication4 
{
    public static void main(String[] args) 
    {
       demoOverloading demo=new demoOverloading(); //creating object for above class
       System.out.println("Sum of Integer "+demo.add(10,20)); //calling integer add method
       System.out.println("Sum of double "+demo.add(33.44,67.5)); //calling double add method
    }
}

The above example having two methods having same name add but one contains int and another contains double arguments, like this we can made with different argument,,

Also possible made difference in number of arguments..

Thank you

What is overloading in Java?

Related

Recent Posts