Tell me about method overloading rules.

Method Overloading in object-oriented programming allows defining multiple methods within the same class with the same name but different signatures.

Main rules for method overloading:

1. Signature difference: A method's signature includes its name and the list of parameter types in the corresponding order. For methods to be considered overloaded, their signatures must differ.

   // Examples of different signatures
   void print(int i) { }
   void print(String s) { }
   void print(int i, String s) { }
   void print(String s, int i) { } // Different parameter order
   

2. Method name must be the same: Overloaded methods should have the same name.

   // Correct example of overloading
   class Example {
       void process(int a) { }
       void process(double b) { }
   }
   

3. Return type is not part of the signature: Changing only the return type does not make methods overloaded. The compiler cannot distinguish which method to call if the parameter signatures are the same.

   // Not overloading - compile error
   int calculate() { return 1; }
   String calculate() { return "error"; }
   

4. Access modifiers and exception specifications do not affect overloading: Similar to return type, changing only access modifiers (public, private, protected, default) or the list of thrown exceptions (throws) does not lead to overloading.

   // Not overloading - compile error if parameter signatures are the same
   public void doSomething() { }
   private void doSomething() { }
   

5. Parameter order matters: Changing the order of parameter types makes signatures different.

   // Overloading
   void setup(int width, int height) { }
   void setup(int height, String unit) { } // Different second parameter
   void setup(String unit, int size) { } // Different type and order
   

6. Number of parameters matters: Different number of parameters leads to different signatures.

   // Overloading
   void log(String message) { }
   void log(String message, int level) { }
   

Thus, the key factor for overloading is the uniqueness of the method signature, which is determined by its name and the set (types and order) of parameters.