Surcharge des opérateurs en Java

Pouvez-vous me dire s'il est possible de surcharger les opérateurs en Java? S'il est utilisé n'importe où en Java, pourriez-vous m'en parler.

Non, Java ne prend pas en charge la surcharge d'opérateurs définis par l'utilisateur. Le seul aspect de Java qui se rapproche de la surcharge d'opérateurs "personnalisés" est la gestion de + pour les chaînes, ce qui entraîne soit une concaténation de constantes au moment de la compilation, soit une concaténation au moment de l'exécution à l'aide de StringBuilder / StringBuffer. Vous ne pouvez pas définir vos propres opérateurs qui agissent de la même manière.

Pour un langage de type Java (et basé sur JVM) qui prend en charge la surcharge d'opérateurs, vous pouvez regarder Kotlin ou Groovy . Alternativement, vous pourriez trouver de la chance avec une solution de plugin de compilateur Java .

La surcharge d'opérateur est utilisée en Java pour la concaténation du type String:

String concat = "one" + "two";

Cependant, vous ne pouvez pas définir vos propres surcharges d'opérateurs.

En plus de toutes les personnes soulignant qu'il +est surchargé pour les chaînes, -est également surchargé pour les opérations à virgule flottante et entière, comme le sont *et /.

[edit] %est également surchargé pour la virgule flottante, ce qui peut être un peu une surprise pour ceux qui ont un fond C ou C ++.

Java n'autorise pas la surcharge des opérateurs. L'approche préférée est de définir une méthode sur votre classe pour effectuer l'action: a.add(b)au lieu de a + b. Vous pouvez voir un résumé des autres bits Java laissés de côté des langages de type C ici: Fonctionnalités supprimées de C et C ++

Vous ne pouvez pas le faire vous-même car Java n'autorise pas la surcharge des opérateurs.

À une exception près, cependant. + et + = sont surchargés pour les objets String.

Comme beaucoup d'autres l'ont répondu: Java ne prend pas en charge la surcharge d'opérateurs définis par l'utilisateur.

C'est peut-être hors sujet, mais je veux faire des commentaires sur certaines choses que j'ai lues dans certaines réponses.

À propos de la lisibilité.
Comparer:

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

Regarde encore!
Lequel est le plus lisible?

Un langage de programmation qui permet la création de types définis par l'utilisateur, devrait leur permettre d'agir de la même manière que les types intégrés (ou types primitifs).

Ainsi, Java rompt un principe fondamental de la programmation générique:
nous devrions être capables d'échanger des objets de types intégrés avec des objets de types définis par l'utilisateur.
(Vous vous demandez peut-être: "A-t-il dit 'objets intégrés'?". Oui, voir ici .)

À propos de la concaténation de chaînes:

Les mathématiciens utilisent le symbole + pour les opérations commutatives sur les ensembles.
Nous pouvons donc être sûrs que a + b = b + a.
La concaténation de chaînes (dans la plupart des langages de programmation) ne respecte pas cette notation mathématique courante.

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

ou en Java:

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

Extra:
Remarquez comment, en Java, l'égalité et l'identité sont confondues. Le symbole == (égalité) signifie:
a. Égalité pour les types primitifs.
b. Vérification d'identité pour les types définis par l'utilisateur, par conséquent, nous sommes obligés d'utiliser la fonction equals () pour l'égalité.
Mais ... Qu'est-ce que cela a à voir avec la surcharge des opérateurs?
Si le langage permet à l'opérateur de surcharger, l'utilisateur pourrait donner le sens approprié à l'opérateur d'égalité.

On peut essayer la surcharge d'opérateur Java . Il a ses propres limites, mais cela vaut la peine d'essayer si vous voulez vraiment utiliser la surcharge d'opérateurs.

Utilisez simplement Xtend avec votre code Java. Il prend en charge la surcharge de l'opérateur:

    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
    }

}

Sur le site officiel, il y a une liste des méthodes à mettre en œuvre pour chaque opérateur!

Ou, vous pouvez créer Java Groovy et simplement surcharger ces fonctions pour obtenir ce que vous voulez

//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 ne veut pas être / utiliser groovy? :RÉ

Non, vous ne pouvez pas utiliser les JAR groovy compilés en Java de la même manière. Il s'agit toujours d'une erreur de compilation pour Java.

Contrairement à C ++, Java ne prend pas en charge la surcharge d'opérateurs définis par l'utilisateur. La surcharge se fait en interne en java.

On peut prendre +(plus) par exemple:

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

Ici, plus ajoute deux nombres entiers et concatène deux chaînes. Nous pouvons donc dire que Java prend en charge la surcharge des opérateurs internes mais pas celle définie par l'utilisateur.