В чем разница между перегрузкой метода и переопределением метода

А, ну это же классика, которую каждый джуниор путает, пока не наступит на грабли, ёпта. Смотри, тут всё просто, как три копейки, если объяснить на пальцах.

Представь себе, что у тебя есть класс Calculator — этакий универсальный солдат для сложения. И вот ты такой думаешь: «Блин, а как мне одним словом описать операцию, чтобы можно было и целые числа сложить, и дробные, и даже три штуки сразу?» Вот тут-то и вырубает перегрузка методов (Overloading). Это когда в одном классе ты городишь кучу методов с одним и тем же именем, но с разными входящими параметрами. Компилятор, видя твой вызов, смотрит на то, какие аргументы ты суёшь в метод, и сам решает, какую именно из одноимённых функций запустить. Это статический полиморфизм, всё решается на этапе компиляции. Чистая магия для удобства.

public class Calculator {
    // Три метода 'add', но они все разные для компа
    public int add(int a, int b) {
        return a + b;
    }
    public double add(double a, double b) {
        return a + b;
    }
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}
// А вот тут уже начинается веселье
Calculator calc = new Calculator();
calc.add(2, 3);      // Комп смотрит: два int'а — ок, держи первый метод.
calc.add(2.5, 3.7);  // О, два double — значит, второй.
calc.add(1, 2, 3);   // Три аргумента? Да это же третий, ебать мои старые костыли!

А теперь другая история, посерьёзнее. Переопределение метода (Overriding) — это уже про наследование и хитрые подмены. Допустим, есть у тебя класс Animal с методом makeSound(). Все животные как бы издают звук. Но вот ты создаёшь класс Dog. И собака, конечно, тоже животное, но её звук — это «Гав-гав», а не какая-то абстрактная хрень. Вот ты в классе Dog пишешь свой метод makeSound() с ТОЧНО ТАКОЙ ЖЕ сигнатурой (имя, параметры, возвращаемый тип), но со своей реализацией. И когда программа запустится, JVM посмотрит не на тип переменной (которая может быть Animal), а на реальный тип объекта, который в ней лежит (а там Dog), и вызовет метод именно из Dog. Это динамический полиморфизм, всё решается в рантайме. Вот это и есть переопределение — замена родительской логики на свою, дочернюю.

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

class Dog extends Animal {
    @Override // Аннотация — кричим компилятору: «Чувак, я специально переписываю метод, не пугайся!»
    public void makeSound() {
        System.out.println("Woof! Woof!");
    }
}

// А вот тут фокусы
Animal myAnimal = new Animal();
myAnimal.makeSound(); // Выведет скучную общую фразу.

myAnimal = new Dog(); // В переменную типа Animal кладём объект Dog. Удивление пиздец, но так можно!
myAnimal.makeSound(); // А вот тут БАЦ! Выведет "Woof! Woof!" Потому что JVM видит, что внутри сидит пёс.

Короче, чтобы не путаться, запомни так:

• Перегрузка — это про УДОБСТВО. Одно имя функции для разных наборов параметров. Всё в одном классе. Решает компилятор.
• Переопределение — это про ИЗМЕНЕНИЕ ПОВЕДЕНИЯ. Меняем работу унаследованного метода в ребёнке. Решает JVM в момент выполнения.

Вот тебе табличка, чтобы окончательно в голове улеглось, а то чувствую, у тебя уже волнение ебать.

Вот и вся магия. Главное — не пытайся перегрузить метод, просто поменяв возвращаемый тип, компилятор тебя не поймёт и пошлёт нахуй. А для переопределения всегда пиши @Override, это спасёт от глупых ошибок, когда ты думаешь, что переопределяешь, а на самом деле создаёшь новый метод.