What can be changed during overload?

Overloading a method or constructor allows you to change:

Parameter types: The sequence and number of parameters can be the same, but at least one parameter type must differ.
```
// Example of overloading by parameter type
void print(int i) { }
void print(String s) { }
```

Number of parameters: Methods or constructors with the same name but different number of parameters.

// Example of overloading by number of parameters
void calculate(int a) { }
void calculate(int a, int b) { }

Order of parameters (when types differ): If there are multiple parameters with different types, changing their order creates a unique signature.

// Example of overloading by parameter order (with different types)
void process(int a, String s) { }
void process(String s, int a) { }

What CANNOT be changed during overloading:

Return type: Overloaded methods can have different return types, but this is not sufficient for overloading. Return type is ignored when determining the method signature.
```
// Not overloading
int getValue() { return 0; }
String getValue() { return ""; }
```
Access modifiers: Access modifiers (public, private, protected, default) do not affect overloading.
Non-access modifiers: Modifiers like static, final, abstract, etc., do not affect overloading.

An example illustrating that changing the return type alone is insufficient for overloading:

class Example {
    // Allowed
    void sum(int a, int b) { }

    // Overloading by parameter type
    void sum(double a, double b) { }

    // Not allowed, as only the return type is changed
    // int sum(int a, int b) { return a + b; }
}

Thus, the key aspect of overloading is having a unique method or constructor signature, which is determined by the combination of name, number, types of parameters, and their order.