What restrictions are placed on method overloading?

by

Two methods may not have the same name and argument list but different return types.

In Core Java, there are certain restrictions placed on method overloading. These restrictions help maintain clarity and consistency in the language. The key restrictions on method overloading in Java are:

  1. Parameter Types and Number: Overloaded methods must have a different number or different types of parameters. The return type alone is not sufficient to distinguish overloaded methods.
    java
    // Valid method overloading
    void example(int x);
    void example(double y);

    // Invalid, only return type is different
    int example(int x);

  2. Access Modifiers and Exceptions: Overloaded methods can have different access modifiers, but the number or types of parameters should be different. However, a method cannot be overloaded just by changing the return type. If a method throws a checked exception, any overloaded version of it must declare the same, subclass, or no exception.
    java
    // Valid method overloading
    public void methodOne(int x);
    private void methodOne(double y);
    public void methodOne(int x, double y);

    // Invalid, changing only the return type
    public int methodTwo(int x);
    public double methodTwo(int x);

  3. Varargs (Variable-Length Argument Lists): If a method accepts a variable number of arguments (varargs), it must be the last parameter.
    java
    // Valid use of varargs
    void varargsExample(int... numbers);

    // Invalid, varargs not last
    void invalidVarargs(int... numbers, double x);

These rules ensure that the overloaded methods can be unambiguously determined by the compiler during method invocation based on the number and types of arguments.