Respuesta.

Históricamente, en algunos lenguajes (por ejemplo, C++), la programación permite sobrecargar los operadores estándar (operator overloading) para hacer que los tipos de datos personalizados sean más "naturales" de usar. En Java, en la fase de diseño del lenguaje, se tomó la decisión de no sobrecargar los operadores para combatir la complejidad excesiva y la dificultad de lectura del código.

El problema es que a veces sería realmente conveniente definir el comportamiento de los operadores para nuestros objetos, por ejemplo, + para la suma de vectores, pero esto no es posible en Java a nivel de sintaxis.

La solución es definir métodos normales (por ejemplo, add, multiply) para trabajar con objetos o utilizar enfoques estándar: sobrescribir los métodos equals() y compareTo() para comparar; o aplicar patrones de diseño (por ejemplo, el patrón "Constructor" o "Compositivo").

Ejemplo de código:

public class Vector {
    private int x, y;
    public Vector(int x, int y) { this.x = x; this.y = y; }

    public Vector add(Vector other) {
        return new Vector(this.x + other.x, this.y + other.y);
    }

    @Override
    public String toString() {
        return "Vector(" + x + ", " + y + ")";
    }
}

Vector v1 = new Vector(1, 2);
Vector v2 = new Vector(3, 4);
Vector sum = v1.add(v2); // "Vector(4, 6)"

Características clave:

Java no soporta la sobrecarga de operadores personalizada
Para los operadores de comparación se utilizan métodos equals(), compareTo(), para las operaciones aritméticas — métodos propios
Este enfoque hace que el código sea claramente legible y predecible

Preguntas trampa.

¿Se puede "sobrecargar" el operador == en Java para nuestras clases de manera que compare valores en lugar de referencias?

No, el operador == siempre compara referencias para objetos de clases. Para comparar valores de objetos, es necesario sobrescribir equals() y usarlo en todas partes donde la equivalencia lógica sea importante.

¿Se puede hacer que "a + b" funcione para nuestras clases?

Solo a través de métodos normales, por ejemplo, a.add(b). La sintaxis de sobrecarga de operadores, como en C++, no es soportada.

¿No se comportan las cadenas (String) como un operador '+' sobrecargado en Java?

De hecho, la concatenación de cadenas utilizando + solo funciona para el tipo String, y se soporta a nivel de compilador — es una regla especial de sintaxis.

Errores comunes y anti-patrones

Esperar que el operador == compare los valores de los objetos
Intentar escribir código como a + b para nuestras clases, cuando tal sintaxis es imposible
No implementar equals() y hashCode(), lo que provoca errores con colecciones

Ejemplo de la vida real

Caso negativo

Un desarrollador para la clase "Punto" utiliza == para comparar dos puntos y espera que la comparación devuelva true cuando las coordenadas coinciden.

Pros:

El código se ve simple

Contras:

Casi siempre da un resultado incorrecto si los puntos se crean en diferentes momentos o con diferentes constructores

Caso positivo

Un desarrollador implementa el método equals() para comparar el contenido de los puntos, y para la suma utiliza el método add().