The core difference between method overloading and rewriting is that overloading is to implement the same name method through different parameter lists in the same class, while rewriting is the method of the subclass redefining the parent class. Specifically: 1. Method overload requires the same method name but different parameters (number, type, or order), to improve code readability and flexibility, such as the add method in the Calculator class; 2. Method rewriting requires the method name, parameters and return types to be exactly the same, and is used to implement runtime polymorphism, such as Dog class rewrites Animal's sound method; 3. Overloading is compile-time polymorphism, while rewriting is runtime polymorphism; 4. Overloading can be used for static methods, while rewriting is only applicable to instance methods.

Method overloading and overriding are two core concepts in Java related to polymorphism, but they serve different purposes and work in different ways.

What's the main difference?

Overloading happens when multiple methods in the same class share the same name but have different parameters (either in number, type, or order).
Overriding occurs when a subclass provides a specific implementation of a method that is already defined in its superclass.

Now let's break down each one with practical examples and use cases.

Method Overloading – Same name, different parameters

Overloading lets you define multiple methods with the same name but different input parameters. It helps make code cleaner and more readable by allowing flexibility in how a method can be called.

When do you use it?

You'll see this often in utility classes or APIs where a function should behave differently depending on what inputs are given.

For example:

 class Calculator {
    int add(int a, int b) {
        return ab;
    }

    double add(double a, double b) {
        return ab;
    }

    int add(int a, int b, int c) {
        return abc;
    }
}

Here, add is overloaded:

• One version takes two integers.
• Another takes two doubles.
• And another takes three integers.

Key points:

• Must change the method signature (number, type, or order of parameters).
• Return type alone doesn't matter — you can't overload just by changing return type.
• Access modifiers or exceptions don't affect overloading either.

Method Overriding – Subclass redefined behavior

Overriding allows a subclass to provide a new implementation for a method inherited from a superclass. This is key for runtime polymorphism in Java.

How does it work?

Let's say we have a base class Animal and a subclass Dog .

 class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

When you call sound() on an object of type Dog , the overridden version runs instead of the one in Animal .

Important rules:

• The method name, return type, and parameters must match exactly .
• The access level can't be more restrictive than the overridden method (eg, can't go from protected to private ).
• Static methods can't be overridden — they can only be hidden.
• Constructors cannot be overridden either.

A common place you'll see this is in GUI event handling or when working with frameworks like Spring or Android, where you're expected to override certain methods to customize behavior.

A few easy things to remember

• Overloading is compile-time polymorphism; overriding is runtime.
• Overloading is within the same class; overriding happens between parent and child classes.
• You can overload any method (including static ones), but you can only override instance methods.
• Use @Override annotation when overriding — it helps catch mistakes early.

So if you're writing Java code and wondering whether to overload or override, think:
Are you working inside the same class and varying input? → Use overloading.
Are you customizing a method from a parent class? → Use overriding.

Basically that's it.

The above is the detailed content of What is method overloading vs overriding in Java?. For more information, please follow other related articles on the PHP Chinese website!