Surcharge de L'opérateur en Java

la surcharge d'Opérateur est utilisé en Java pour la concaténation de la Chaîne de caractères du type:

String concat = "one" + "two";

cependant, vous ne pouvez pas définir vos propres surcharges d'opérateur.

en plus de toutes les personnes soulignant que + est surchargé pour les cordes, - est également surchargé pour les opérations à virgule flottante et entier, comme sont * et / .

[modifier] % est aussi surchargé pour floating point, ce qui peut être une surprise pour ceux qui ont un arrière-plan C ou C++.

Java ne permet pas la surcharge de l'opérateur. L'approche privilégiée consiste à 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 exclus de C comme les langues ici: fonctionnalités supprimées de C et C++

vous ne pouvez pas faire cela vous-même puisque Java ne permet pas la surcharge de l'opérateur.

Avec un exception, toutefois. + et += sont surchargés pour les objets String.

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

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 !

comme beaucoup d'autres ont répondu: Java ne supporte pas la surcharge de l'opérateur défini par l'utilisateur.

peut-être que c'est hors-sujet, mais je veux commenter certaines choses que je lis dans certaines réponses.

à propos de la lisibilité.

Comparer:

1. c = a + b
2. c = A. Ajouter B)

regardez encore!

lequel est le plus lisible?

Un langage de programmation qui permet de créer des 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).

donc Java viole un principe fondamental de la programmation générique:

nous devrions pouvoir échanger des objets de types intégrés avec des objets de types définis par l'utilisateur.

(Vous vous demandez peut-être: "N'a-t-il dit d'objets intégré?". Oui, voir ici .)

à propos de la concaténation des cordes:

les mathématiciens utilisent le symnol + pour les opérations commutatives sur les ensembles.

Nous pouvons donc être sûrs que a + b = b + a.

La concaténation des chaînes (dans la plupart des langages de programmation) ne respecte pas cette norme la notation mathématique.

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

Supplémentaire:

Remarquez comment en Java, l'égalité et l'identité sont confus. Le symbole = = (égalité) signifie:

A. Égalité pour les types primitifs

B. Vérification d'identité pour les types définis par l'utilisateur, nous sommes donc obligés d'utiliser la fonction égale () pour égalité.

Mais... Ce que cela a à voir avec la surcharge d'opérateur?

Si la langue permet à l'opérateur de surcharger, l'utilisateur pourrait donner le sens approprié à l'opérateur d'égalité.

ou, vous pouvez faire Java Groovy et juste surcharger ces fonctions pour atteindre 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? : D

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