Operador sobrecarregado em Java

Por favor, você pode me dizer se é possível sobrecarregar os operadores em Java? Se for usado em qualquer lugar em Java, você poderia me contar sobre isso.

Não, o Java não suporta sobrecarga de operador definida pelo usuário. O único aspecto de Java que se aproxima da sobrecarga de operadores “personalizada” é o tratamento de + para strings, que resulta na concatenação de constantes em tempo de compilation ou concatenação em tempo de execução usando StringBuilder / StringBuffer. Você não pode definir seus próprios operadores, que agem da mesma maneira embora.

Para uma linguagem semelhante a Java (e baseada em JVM) que suporta a sobrecarga do operador, você poderia examinar o Groovy . Alternativamente, você pode encontrar sorte com uma solução de plugin do compilador Java .

A sobrecarga do operador é usada em Java para a concatenação do tipo String:

 String concat = "one" + "two"; 

No entanto, você não pode definir suas próprias sobrecargas de operador.

Além de todas as pessoas apontando que + está sobrecarregado para Strings, - também está sobrecarregado para operações de ponto flutuante e inteiro, como são * e / .

[edit] % também está sobrecarregado para ponto flutuante, o que pode ser um pouco surpreendente para aqueles com um background em C ou C ++.

Java não permite a sobrecarga do operador. A abordagem preferida é definir um método em sua class para executar a ação: a.add(b) vez de a + b . Você pode ver um resumo dos outros bits que Java deixou de fora das linguagens como C aqui: Recursos Removidos de C e C ++

Você não pode fazer isso sozinho, pois o Java não permite a sobrecarga do operador.

Com uma exceção, no entanto. + e + = estão sobrecarregados para objects String.

Pode-se tentar Sobrecarga de Operador Java . Ele tem suas próprias limitações, mas vale a pena tentar se você realmente quiser usar a sobrecarga do operador.

Apenas use o Xtend junto com seu código Java. Suporta Sobrecarga do 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 } } 

No site oficial, há uma lista dos methods a serem implementados para cada operador!

Como muitos outros responderam: o Java não suporta sobrecarga de operador definida pelo usuário.

Talvez isso seja fora do tópico, mas quero comentar algumas coisas que li em algumas respostas.

Sobre a legibilidade.
Comparar:

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

Olhe novamente!
Qual deles é mais legível?

Uma linguagem de programação que permita a criação de tipos definidos pelo usuário deve permitir que eles atuem da mesma maneira que os tipos internos (ou tipos primitivos).

Então Java quebra um princípio fundamental da Programação Genérica:
Devemos ser capazes de trocar objects de tipos embutidos com objects de tipos definidos pelo usuário.
(Você pode estar se perguntando: “Ele disse ‘objects de built-in’?”. Sim, veja aqui .)

Sobre a concatenação de strings:

Os matemáticos usam o symnol + para operações comutativas em conjuntos.
Então podemos ter certeza que a + b = b + a.
A concatenação de cadeias de caracteres (na maioria das linguagens de programação) não respeita essa notação matemática comum.

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

ou em Java:

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

Extra:
Observe como, em Java, igualdade e identidade são confusas. O símbolo == (igualdade) significa:
uma. Igualdade para tipos primitivos
b. Verificação de identidade para tipos definidos pelo usuário, portanto, somos forçados a usar a function equals () para igualdade.
Mas … O que isso tem a ver com a sobrecarga do operador?
Se a linguagem permitir a sobrecarga do operador, o usuário poderia dar o significado adequado ao operador de igualdade.

Ou você pode fazer o Java Groovy e apenas sobrecarregar essas funções para conseguir o que você quer

 //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 

Quem não quer ser / usar groovy? : D

Não, você não pode usar os JARs groovy compilados em Java da mesma maneira. Ainda é um erro do compilador para Java.