Risposta.

Storicamente in alcuni linguaggi (ad esempio, C++), la programmazione consente di sovraccaricare gli operatori standard (operator overloading) per rendere i tipi di dati personalizzati più "naturali" nell'uso. In Java, nella fase di progettazione del linguaggio, è stata presa la decisione di non sovraccaricare gli operatori, per combattere la complessità e la difficoltà di lettura del codice.

Problema è che a volte sarebbe davvero comodo definire per i propri oggetti il comportamento degli operatori, ad esempio, + per l'addizione di vettori, ma questo in Java non è consentito a livello di sintassi.

Soluzione — definire metodi normali (ad esempio, add, multiply) per lavorare con oggetti oppure utilizzare approcci standard: sovrascrivere i metodi equals() e compareTo() per il confronto; oppure applicare design pattern (ad esempio, il pattern "Builder" o "Composite").

Esempio di codice:

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)"

Caratteristiche principali:

Java non supporta il sovraccarico degli operatori personalizzati
Per gli operatori di confronto si utilizzano i metodi equals(), compareTo(), per le operazioni aritmetiche — metodi propri
Questo approccio rende il codice esplicitamente leggibile e prevedibile

Domande trabocchetto.

È possibile in Java "sovraccaricare" l'operatore == per le proprie classi in modo che confronti i valori e non i riferimenti?

No, l'operatore == confronta sempre i riferimenti per gli oggetti delle classi. Per confrontare i valori degli oggetti è necessario sovrascrivere equals() e utilizzarlo ovunque sia importante l'equivalenza logica.

È possibile in qualche modo far comportare "a + b" per le proprie classi?

Solo tramite metodi normali, ad esempio, a.add(b). La sintassi del sovraccarico operatori, come in C++, non è supportata.

E le stringhe (String) non si comportano come un operatore '+' sovraccaricato in Java?

In realtà, la concatenazione delle stringhe tramite + funziona solo per il tipo String ed è supportata a livello di compilatore — è una regola sintattica speciale.

Errori comuni e anti-pattern

Aspettarsi che l'operatore == confronti i valori degli oggetti
Provare a scrivere codice del tipo a + b per le proprie classi, mentre tale sintassi non è possibile
Non implementare equals() e hashCode(), causando bug con le collezioni

Esempio dalla vita reale

Caso negativo

Uno sviluppatore per la classe "Punto" utilizza == per confrontare due punti e si aspetta che il confronto restituisca true se le coordinate coincidono.

Pro:

Il codice sembra semplice

Contro:

Quasi sempre restituisce un risultato errato se i punti sono stati creati in momenti diversi o con costruttori diversi

Caso positivo

Uno sviluppatore implementa il metodo equals() per confrontare il contenuto dei punti, mentre per l'addizione utilizza il metodo add().