Sobrecarga de operador 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ê pode me falar sobre isso.

Não, o Java não suporta sobrecarga de operador definida pelo usuário. O único aspecto do Java que se aproxima da sobrecarga "personalizada" do operador é o tratamento de + para seqüências de caracteres, o que resulta em concatenação de constantes em tempo de compilação 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.

Para uma linguagem Java-like (e baseado em JVM), que faz a sobrecarga de operador de suporte, você pode olhar para Kotlin ou Groovy . Como alternativa, você pode ter sorte com uma solução de plug-in 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 que apontam que +está sobrecarregado para Strings, -também está sobrecarregado para operações de ponto flutuante e número inteiro, como são *e /.

[edit] %também está sobrecarregado para ponto flutuante, o que pode ser uma surpresa para quem tem um background em C ou C ++.

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

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

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

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

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

Sobre legibilidade.
Comparar:

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

Olhe novamente!
Qual é mais legível?

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

Portanto, o Java quebra um princípio fundamental da Programação Genérica:
devemos poder trocar objetos de tipos internos com objetos de tipos definidos pelo usuário.
(Você pode estar se perguntando: "Ele disse 'objetos embutidos'?". Sim, veja aqui .)

Sobre a concatenação de String:

Os matemáticos usam o símbolo + para operações comutativas em conjuntos.
Portanto, podemos ter certeza de que a + b = b + a.
A concatenação de strings (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 a igualdade e a identidade são confusas. O símbolo == (igualdade) significa:
a. Igualdade para tipos primitivos.
b. A verificação de identidade para tipos definidos pelo usuário, portanto, somos forçados a usar a função equals () para igualdade.
Mas ... O que isso tem a ver com sobrecarga do operador?
Se o idioma permitir que o operador sobrecarregue, o usuário poderá dar o significado adequado ao operador de igualdade.

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

Basta usar o Xtend junto com o seu código Java. Ele 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 métodos a serem implementados para cada operador!

Ou você pode criar o Java Groovy e sobrecarregar essas funções para obter o que deseja

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

Ao contrário do C ++, o Java não suporta sobrecarga de operador definida pelo usuário. A sobrecarga é feita internamente em java.

Podemos pegar +(mais) por exemplo:

int a = 2 + 4;
string = "hello" + "world";

Aqui, plus adiciona dois números inteiros e concatena duas strings. Portanto, podemos dizer que Java suporta sobrecarga de operador interno, mas não definido pelo usuário.