Java est-il "pass-by-reference" ou "pass-by-value" ?

Question

J'ai toujours pensé que Java utilisait passe par référence .

Cependant, j'ai vu un article de blog qui prétend que Java utilise pass-by-value .

Je ne crois pas comprendre la distinction qu'ils font.

Quelle est l'explication ?

Answer 1

Java est toujours pass-by-value . Malheureusement, lorsque nous traitons des objets, nous traitons en réalité des objets-mains appelés références qui sont également transmises par valeur. Cette terminologie et cette sémantique déroutent facilement de nombreux débutants.

C'est comme ça :

public static void main(String[] args) {
    Dog aDog = new Dog("Max");
    Dog oldDog = aDog;

    // we pass the object to foo
    foo(aDog);
    // aDog variable is still pointing to the "Max" dog when foo(...) returns
    aDog.getName().equals("Max"); // true
    aDog.getName().equals("Fifi"); // false
    aDog == oldDog; // true
}

public static void foo(Dog d) {
    d.getName().equals("Max"); // true
    // change d inside of foo() to point to a new Dog instance "Fifi"
    d = new Dog("Fifi");
    d.getName().equals("Fifi"); // true
}

Dans l'exemple ci-dessus aDog.getName() retournera toujours "Max" . La valeur aDog sur main n'est pas modifié dans la fonction foo avec le Dog "Fifi" car la référence de l'objet est passée par valeur. S'il était passé par référence, alors le aDog.getName() en main rendrait "Fifi" après l'appel à foo .

De même :

public static void main(String[] args) {
    Dog aDog = new Dog("Max");
    Dog oldDog = aDog;

    foo(aDog);
    // when foo(...) returns, the name of the dog has been changed to "Fifi"
    aDog.getName().equals("Fifi"); // true
    // but it is still the same dog:
    aDog == oldDog; // true
}

public static void foo(Dog d) {
    d.getName().equals("Max"); // true
    // this changes the name of d to be "Fifi"
    d.setName("Fifi");
}

Dans l'exemple ci-dessus, Fifi est le nom du chien après l'appel à foo(aDog) car le nom de l'objet a été défini à l'intérieur de l'élément foo(...) . Toute opération qui foo effectue sur d sont telles que, à toutes fins utiles, elles sont réalisées sur aDog mais c'est no possible de changer la valeur de la variable aDog lui-même.

Pour plus d'informations sur le passage par référence et le passage par valeur, consultez la réponse SO suivante : https://stackoverflow.com/a/430958/6005228 . Ceci explique plus en détail la sémantique et l'histoire des deux et explique également pourquoi Java et de nombreux autres langages modernes semblent faire les deux dans certains cas.

Answer 2

Je viens de remarquer que vous avez fait référence mon article .

La spécification Java dit que tout en Java est de type pass-by-value. La notion de "pass-by-reference" n'existe pas en Java.

La clé pour comprendre cela est que quelque chose comme

Dog myDog;

est no un chien ; il s'agit en fait d'un pointeur à un chien. L'utilisation du terme "référence" en Java est très trompeuse et est à l'origine de la plupart des confusions ici. Ce qu'ils appellent des "références" agissent/se sentent plus comme ce que nous appelons des "pointeurs" dans la plupart des autres langages.

Ce que cela signifie, c'est que lorsque vous avez

Dog myDog = new Dog("Rover");
foo(myDog);

vous passez essentiellement le adresse de la création Dog à l'objet foo méthode.

(Je dis essentiellement parce que les pointeurs/références Java ne sont pas des adresses directes, mais il est plus facile d'y penser de cette façon).

Supposons que le Dog réside à l'adresse mémoire 42. Cela signifie que nous passons 42 à la méthode.

si la Méthode était définie comme

public void foo(Dog someDog) {
    someDog.setName("Max");     // AAA
    someDog = new Dog("Fifi");  // BBB
    someDog.setName("Rowlf");   // CCC
}

regardons ce qui se passe.

• le paramètre someDog est fixé à la valeur 42
• à la ligne "AAA"
  • someDog est suivi jusqu'au Dog vers lequel il pointe (le Dog à l'adresse 42)
  • que Dog (celui de l'adresse 42) est prié de changer son nom en Max
• à la ligne "BBB
  • une nouvelle Dog est créé. Disons qu'il est à l'adresse 74
  • nous attribuons le paramètre someDog à 74
• à la ligne "CCC"
  • someDog est suivi jusqu'à la Dog vers lequel il pointe (le Dog à l'adresse 74)
  • que Dog (celui de l'adresse 74) est prié de changer son nom en Rowlf
• alors, nous retournons

Réfléchissons maintenant à ce qui se passe en dehors de la méthode :

Est-ce que myDog changement ?

Voilà la clé.

En gardant à l'esprit que myDog est un pointeur et non un véritable Dog la réponse est NON. myDog a toujours la valeur 42 ; il pointe toujours vers l'objet original Dog (mais notez qu'à cause de la ligne "AAA", son nom est maintenant "Max" - toujours le même chien ; myDog La valeur de l'entreprise n'a pas changé).

C'est parfaitement valable de suivez une adresse et changer ce qui se trouve à la fin de celle-ci ; cela ne change pas la variable, cependant.

Java fonctionne exactement comme le C. Vous pouvez assigner un pointeur, passer le pointeur à une méthode, suivre le pointeur dans la méthode et modifier les données qui ont été pointées. Toutefois, l'appelant ne verra pas les modifications que vous apportez à l'endroit où pointe ce pointeur. (Dans un langage avec une sémantique pass-by-reference, la fonction méthode peut changer le pointeur et l'appelant verra ce changement).

En C++, Ada, Pascal et d'autres langages qui supportent le pass-by-reference, vous pouvez réellement changer la variable qui a été passée.

Si Java disposait d'une sémantique pass-by-reference, l'option foo que nous avons définie ci-dessus aurait changé l'endroit où myDog pointait lorsqu'il a assigné someDog sur la ligne BBB.

Pensez aux paramètres de référence comme étant des alias pour la variable passée. Lorsque cet alias est attribué, la variable transmise l'est également.

Answer 3

Java passe toujours les arguments par valeur PAS par référence.

---

Laissez-moi vous expliquer cela à travers un exemple :

public class Main {

     public static void main(String[] args) {
          Foo f = new Foo("f");
          changeReference(f); // It won't change the reference!
          modifyReference(f); // It will modify the object that the reference variable "f" refers to!
     }

     public static void changeReference(Foo a) {
          Foo b = new Foo("b");
          a = b;
     }

     public static void modifyReference(Foo c) {
          c.setAttribute("c");
     }

}

Je vais vous expliquer cela par étapes :

1. Déclarer une référence nommée f de type Foo et lui attribuer un nouvel objet de type Foo avec un attribut "f" .

   Foo f = new Foo("f");

   

2. Du côté de la méthode, une référence de type Foo avec un nom a est déclaré et on lui attribue initialement null .

   public static void changeReference(Foo a)

   

3. Lorsque vous appelez la méthode changeReference la référence a se verra attribuer l'objet qui est passé comme argument.

   changeReference(f);

   

4. Déclarer une référence nommée b de type Foo et lui attribuer un nouvel objet de type Foo avec un attribut "b" .

   Foo b = new Foo("b");

   

5. a = b effectue une nouvelle affectation à la référence a , no f de l'objet dont l'attribut est "b" .

   

6. Comme vous le dites modifyReference(Foo c) méthode, une référence c est créé et l'objet avec l'attribut "f" .

   

7. c.setAttribute("c"); changera l'attribut de l'objet qui référence c pointe vers lui, et c'est le même objet que la référence f l'indique.

   

J'espère que vous comprenez maintenant comment passer des objets comme arguments en Java :)

Answer 4

En Java, on passe toujours par valeur, sans exception, jamais .

Comment se fait-il donc que quelqu'un puisse être confus par cela, et croire que Java est une référence passive, ou penser qu'il a un exemple de Java agissant comme une référence passive ? Le point essentiel est que Java jamais fournit un accès direct aux valeurs de les objets eux-mêmes en cualquier circonstances. Le seul accès aux objets se fait par le biais d'un référence à cet objet. Comme les objets Java sont siempre auxquels on accède par le biais d'une référence, plutôt que directement, il est courant de parler de champs et de variables et les arguments de la méthode comme étant objets alors qu'en réalité, ils ne sont que références à des objets . La confusion provient de ce changement de nomenclature (incorrect à proprement parler).

Ainsi, lors de l'appel d'une méthode

• Pour les arguments primitifs ( int , long etc.), la valeur de passage est la suivante la valeur réelle de la primitive (par exemple, 3).
• Pour les objets, le passage par la valeur est la valeur de la référence à l'objet .

Donc si vous avez doSomething(foo) y public void doSomething(Foo foo) { .. } les deux Foos ont copié références qui pointent vers les mêmes objets.

Naturellement, passer par valeur une référence à un objet ressemble beaucoup (et est indiscernable en pratique) à passer un objet par référence.

Answer 5

Cela vous donnera un aperçu de la façon dont Java fonctionne réellement, à tel point que lors de votre prochaine discussion sur le passage par référence ou le passage par valeur de Java, vous sourirez simplement :-)

Première étape : effacez de votre esprit le mot qui commence par "p" "_ _ _ _ _ _ _", surtout si vous venez d'autres langages de programmation. Java et 'p' ne peuvent pas être écrits dans le même livre, forum, ou même txt.

Deuxième étape : n'oubliez pas que lorsque vous passez un objet dans une méthode, vous passez la référence de l'objet et non l'objet lui-même.

• Étudiant : Maître, cela veut-il dire que Java est pass-by-reference ?
• Maître : Sauterelle, non.

Maintenant, pensez à ce que fait/est la référence/variable d'un objet :

1. Une variable contient les bits qui indiquent à la JVM comment atteindre l'objet référencé en mémoire (Heap).
2. Lorsque vous passez des arguments à une méthode vous ne passez PAS la variable de référence, mais une copie des bits dans la variable de référence . Quelque chose comme ça : 3bad086a. 3bad086a représente un moyen d'accéder à l'objet passé.
3. Donc tu passes juste 3bad086a que c'est la valeur de la référence.
4. Vous passez la valeur de la référence et non la référence elle-même (et non l'objet).
5. Cette valeur est en fait COPIEE et donnée à la méthode .

Dans ce qui suit (n'essayez pas de compiler/exécuter ceci...) :

1. Person person;
2. person = new Person("Tom");
3. changeName(person);
4.
5. //I didn't use Person person below as an argument to be nice
6. static void changeName(Person anotherReferenceToTheSamePersonObject) {
7.     anotherReferenceToTheSamePersonObject.setName("Jerry");
8. }

Que se passe-t-il ?

• La variable personne est créé à la ligne 1 et il est nul au début.
• Un nouvel objet Personne est créé à la ligne 2, stocké en mémoire, et la variable personne reçoit la référence de l'objet Personne. C'est-à-dire son adresse. Disons 3bad086a.
• La variable personne contenant l'adresse de l'objet est passée à la fonction dans la ligne #3.
• Dans la ligne 4, vous pouvez écouter le son du silence.
• Vérifiez le commentaire de la ligne 5
• Une méthode variable locale - autreReferenceToTheSamePersonObject - est créé et ensuite vient la magie de la ligne 6 :
  • La variable/référence personne est copié bit par bit et transmis à autreReferenceToTheSamePersonObject à l'intérieur de la fonction.
  • Aucune nouvelle instance de Personne n'est créée.
  • Les deux " personne " et " autreReferenceToTheSamePersonObject " ont la même valeur de 3bad086a.
  • Ne l'essayez pas, mais person==une autre référence au même objet-personne serait vrai.
  • Les deux variables ont des COPIES IDENTIQUES de la référence et elles font toutes deux référence au même objet personne, le MÊME objet sur le tas et NON UNE COPIE.

Une image vaut mille mots :

Notez que les flèches anotherReferenceToTheSamePersonObject sont dirigées vers l'objet et non vers la variable person !

Si tu n'as pas compris, fais-moi confiance et rappelle-toi que c'est mieux de dire que Java est une méthode de transmission par valeur . Bien, passer par une valeur de référence . Oh bien, encore mieux c'est passe-par-copie-de-la-variable-valeur ! ;)

Maintenant, sentez-vous libre de me haïr, mais notez que compte tenu de cette il n'y a pas de différence entre le passage de types de données primitifs et d'Objets quand on parle d'arguments de méthode.

Vous passez toujours une copie des bits de la valeur de la référence !

• S'il s'agit d'un type de données primitif, ces bits contiendront la valeur du type de données primitif lui-même.
• S'il s'agit d'un objet, les bits contiennent la valeur de l'adresse qui indique à la JVM comment accéder à l'objet.

Java est de type pass-by-value parce qu'à l'intérieur d'une méthode, vous pouvez modifier l'objet référencé autant que vous le voulez, mais peu importe vos efforts, vous ne pourrez jamais modifier la variable passée qui continuera à référencer (pas p _ _ _ _ _ _) le même objet quoi qu'il arrive !

---

La fonction changeName ci-dessus ne sera jamais en mesure de modifier le contenu réel (les valeurs binaires) de la référence passée. En d'autres termes, changeName ne peut pas faire en sorte qu'une personne fasse référence à un autre objet.

---

Bien sûr, vous pouvez faire court et juste dire que Java est de type pass-by-value !