Ответ.

Java не поддерживает прямую перегрузку операторов так, как это реализовано, например, в C++. Исторически такое ограничение было введено для упрощения чтения кода и уменьшения двусмысленности: Бьерн Страуструп (создатель C++) и Джеймс Гослинг (создатель Java) обсуждали этот вопрос, и в Java было принято решение не позволять разработчикам определять собственное поведение операторов для своих классов.

Проблема перегрузки операторов заключается в том, что избыточная свобода в определении арифметики и логики для пользовательских классов может привести к трудноотслеживаемым багам и ухудшению читаемости кода, особенно в больших командах.

Решение — запретить пользовательскую перегрузку операторов. Тем не менее, Java внутри своих классов поддерживает перегрузку методов (overloading), а поведение операторов может быть имитировано через явно определённые методы (например, .add(), .equals().compareTo() и т.д.).

Пример кода:

public class Vector2D {
    private final int x, y;
    public Vector2D(int x, int y) {
        this.x = x; this.y = y;
    }
    public Vector2D add(Vector2D other) {
        return new Vector2D(this.x + other.x, this.y + other.y);
    }
}

Vector2D v1 = new Vector2D(2, 3);
Vector2D v2 = new Vector2D(1, 4);
Vector2D sum = v1.add(v2); // вместо v1 + v2

Ключевые особенности:

Явная передача семантики операций через методы, а не через операторную перегрузку
Поведение стандартных операторов (например, "+", "-") нельзя изменить для пользовательских классов
Исключением является перегрузка операций для строк: оператор "+" вызывает concat()

Вопросы с подвохом.

А можно ли в Java перегрузить оператор "+" для своего класса, чтобы складывать объекты?

Ответ: Нет, Java не поддерживает пользовательскую перегрузку арифметических операторов для создаваемых классов. Исключение сделано только для строк: оператор "+" вызывает конкатенацию через StringBuilder.

Если определить метод equals(), будет ли оператор "==" работать как сравнение значений?

Ответ: Нет, оператор "==" сравнивает ссылки на объекты, а не их содержимое. Для корректного сравнения значений используют переопределённый equals().

String a = new String("hello");
String b = new String("hello");
System.out.println(a == b);    // false
System.out.println(a.equals(b)); // true

Есть ли исключения, где стандартный оператор ведёт себя по-особому для нестандартных классов?

Ответ: "Особое" поведение в Java реализовано только для String c оператором "+" и для примитивных типов (автоматическое продвижение и unboxing). Для остальных классов операторы работают стандартно (то есть не перегружаются).

Типовые ошибки и анти-паттерны

Попытка перегрузить операторы при проектировании своего класса (например, ожидание, что "==" сравнивает значения)
Использование "==" вместо .equals() для строк и других объектов
Слишком сложные имитации перегрузки через статические методы, мешающие читабельности

Пример из жизни

Негативный кейс

Молодой разработчик написал класс Money и стал сравнивать два объекта через "==", считая, что они сравнятся по значениям. Из-за этого возникли ошибки при проверке на равенство, которые проявились только в продакшене.

Плюсы:

В коротких программах иногда ошибка остаётся незаметной до тестов

Минусы:

Некорректная семантика операций сравнения, трудность отладки
Затраты времени на разъяснения в команде

Позитивный кейс

В проекте был написан свой класс Vector, все арифметические операции реализованы явно, оператор == не используется для объектов, и документация описывает семантику работы методов.