Method Overloading vs. Method Overriding in Java

Question

What are the key differences between method overloading and method overriding in Java? Provide examples and explain when to use each.

Answer

Method overloading and method overriding are two different ways to achieve polymorphism in Java, but they serve different purposes and have distinct characteristics.

Method Overloading

Method overloading occurs when a class has multiple methods with the same name but different parameters. It's a form of compile-time polymorphism.

Characteristics:

1. Same method name
2. Different parameter types or number of parameters
3. Can have different return types
4. Can have different access modifiers
5. Can throw different exceptions
6. Must be in the same class

Example:

public class Calculator {
    // Different parameter types
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }

    // Different number of parameters
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // Different return type
    public String add(String a, String b) {
        return a + b;
    }
}

Method Overriding

Method overriding occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. It's a form of runtime polymorphism.

Characteristics:

1. Same method name
2. Same parameter types and order
3. Same return type (or covariant return type)
4. Cannot reduce visibility
5. Cannot throw broader checked exceptions
6. Must be in different classes (subclass and superclass)

Example:

public class Animal {
    public void makeSound() {
        System.out.println("Some sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

Key Differences

1. Timing of Resolution

   // Overloading - resolved at compile time
   public class OverloadExample {
       public void process(int x) {}
       public void process(String x) {}
   
       public static void main(String[] args) {
           OverloadExample e = new OverloadExample();
           e.process(5);    // Calls process(int)
           e.process("5");  // Calls process(String)
       }
   }
   
   // Overriding - resolved at runtime
   public class OverrideExample {
       public static void main(String[] args) {
           Animal animal = new Dog();  // Runtime polymorphism
           animal.makeSound();  // Calls Dog's makeSound()
       }
   }
   

2. Parameter Requirements

   // Overloading - different parameters required
   public class OverloadDemo {
       public void method(int x) {}
       public void method(String x) {}  // Different parameter type
       public void method(int x, int y) {}  // Different number of parameters
   }
   
   // Overriding - same parameters required
   public class OverrideDemo {
       class Parent {
           public void method(int x) {}
       }
   
       class Child extends Parent {
           @Override
           public void method(int x) {}  // Must have same parameters
       }
   }
   

3. Return Type Rules

   // Overloading - can have different return types
   public class OverloadReturn {
       public int getValue(int x) { return x; }
       public String getValue(String x) { return x; }
   }
   
   // Overriding - must have same or covariant return type
   public class OverrideReturn {
       class Parent {
           public Number getValue() { return 1; }
       }
   
       class Child extends Parent {
           @Override
           public Integer getValue() { return 1; }  // Valid (covariant)
       }
   }
   

When to Use Each

Use Method Overloading When:

1. Providing similar functionality with different parameter types
2. Creating convenience methods
3. Handling different input formats
4. Providing default parameter values

Example:

public class Logger {
    public void log(String message) {
        log(message, Level.INFO);
    }

    public void log(String message, Level level) {
        // Implementation
    }

    public void log(String message, Level level, Throwable error) {
        // Implementation
    }
}

Use Method Overriding When:

1. Implementing polymorphism
2. Providing specific behavior in subclasses
3. Implementing interface methods
4. Extending existing functionality

Example:

public abstract class PaymentProcessor {
    public abstract void processPayment(double amount);
}

public class CreditCardProcessor extends PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        // Credit card specific implementation
    }
}

public class PayPalProcessor extends PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        // PayPal specific implementation
    }
}

Best Practices

1. For Overloading:
2. Keep overloaded methods logically related
3. Use clear parameter names
4. Consider using builder pattern for complex overloads

5. Document parameter differences

6. For Overriding:

7. Always use @Override annotation
8. Maintain Liskov Substitution Principle
9. Call super.method() when needed
10. Don't override Object methods unless necessary

Common Pitfalls

1. Overloading Pitfalls:

   public class OverloadPitfall {
       public void process(int x) {}
       public void process(Integer x) {}  // Can cause confusion
   
       public static void main(String[] args) {
           OverloadPitfall p = new OverloadPitfall();
           p.process(null);  // Ambiguous call
       }
   }
   

2. Overriding Pitfalls:

   public class OverridePitfall {
       class Parent {
           public void method() {}
       }
   
       class Child extends Parent {
           public void method() {}  // Missing @Override
           // Could be a new method instead of override
       }
   }