Sobrecarga de operadores en Java

La sobrecarga del operador se utiliza en Java para la concatenación del tipo de cadena:

String concat = "one" + "two";

Sin embargo, no puede definir sus propias sobrecargas de operador.

Además de todas las personas que señalan que + está sobrecargado para Cadenas, - también está sobrecargado tanto para operaciones de coma flotante como de enteros, al igual que * y /.

[editar] % también está sobrecargado por coma flotante, lo que puede ser una sorpresa para aquellos con un fondo de C o C++.

Java no permite la sobrecarga del operador. El enfoque preferido es definir un método en su clase para realizar la acción: a.add(b) en lugar de a + b. Puede ver un resumen de los otros bits que Java dejó fuera de C como lenguajes aquí: Características eliminadas de C y C++

No puede hacer esto usted mismo ya que Java no permite la sobrecarga del operador.

Con una excepción, sin embargo. + y += están sobrecargados para objetos String.

Se puede intentar Sobrecargar el operador Java. Tiene sus propias limitaciones, pero vale la pena intentarlo si realmente desea utilizar la sobrecarga del operador.

Simplemente use Xtend junto con su código Java. Soporta Sobrecarga del Operador:

    package com.example;

@SuppressWarnings("all")
public class Test {
  protected int wrapped;

  public Test(final int value) {
    this.wrapped = value;
  }

  public int operator_plus(final Test e2) {
    return (this.wrapped + e2.wrapped);
  }
}

package com.example

class Test2 {

    new() {
        val t1 = new Test(3)
        val t2 = new Test(5)
        val t3 = t1 + t2
    }

}

En el sitio web oficial, hay una lista de los métodos a implementar para cada operador !

Como muchos otros han respondido: Java no soporta sobrecarga de operador definida por el usuario.

Tal vez esto está fuera de tema, pero quiero comentar algunas cosas que leí en algunas respuestas.

Sobre la legibilidad.
Comparar:

1. c = a + b
2. c = a. add (b)

¡Mira de nuevo!
¿Cuál es más legible?

Un lenguaje de programación que permita la creación de tipos definidos por el usuario, debería permitirles actuar de la misma manera que los tipos incorporados (o tipos primitivos).

Así que Java rompe un principio fundamental de la Programación Genérica:
Deberíamos ser capaces de intercambiar objetos de tipos incorporados con objetos de tipos definidos por el usuario.
(Usted puede preguntarse: "¿Dijo 'objetos de built-in'?". Sí, ver aquí.)

Acerca de la concatenación de cadenas:

Los matemáticos usan el symnol + para operaciones conmutativas en conjuntos.
Así que podemos estar seguros de que a + b = b + a.
La concatenación de cadenas (en la mayoría de los lenguajes de programación) no respeta esta notación matemática común.

a := "hello";
b := "world";
c := (a + b = b + a);

O en Java:

String a = "hello";
String b = "world";
boolean c = (a + b).equals(b + a);

Extra:
Observe cómo en Java la igualdad y la identidad se confunden. El símbolo == (igualdad) significa:
a. Igualdad para los tipos primitivos
b. Identity-check for user-defined types, therefore, we are forced to use the function equals() for equality.
Pero... Qué tiene esto que ver con operator la sobrecarga?
Si el lenguaje permite la sobrecarga del operador, el usuario podría dar el significado adecuado al operador de igualdad.

O bien, puedes hacer que Java sea genial y simplemente sobrecargar estas funciones para lograr lo que quieres

//plus() => for the + operator
//multiply() => for the * operator
//leftShift() = for the << operator
// ... and so on ...

class Fish {
    def leftShift(Fish fish) {
        print "You just << (left shifted) some fish "
    }
}


def fish = new Fish()
def fish2 = new Fish()

fish << fish2

¿Quién no quiere ser/usar groovy? : D

No no puede usar los JARs groovy compilados en Java de la misma manera. Todavía es un error del compilador para Java.