Java transmet-il les objets par valeur ou par référence ?

Java : passage par valeur ou passage par référence

En Java, des idées fausses surgissent souvent concernant les mécanismes de passage d'objets. Cet article approfondira la distinction entre deux extraits de code, mettant en lumière les principes fondamentaux du comportement de transmission des paramètres de Java.

Code A vs Code B

Code A :

Foo myFoo;
myFoo = createfoo();

public Foo createFoo() {
   Foo foo = new Foo();
   return foo;
}

Code B :

Foo myFoo;
createFoo(myFoo);

public void createFoo(Foo foo) {
   Foo f = new Foo();
   foo = f;
}

Comprendre le passage de paramètres de Java

Contrairement à la croyance populaire, Java utilise le passage par valeur et non par référence. Cela signifie que lorsqu'un objet est passé en argument, une copie de sa référence est créée plutôt qu'une référence directe à l'original.

Explication du code A

Dans la première ligne, myFoo est déclaré mais non attribué. La deuxième ligne appelle la méthode createFoo, qui renvoie un nouvel objet Foo attribué à myFoo. Cette affectation crée un nouvel objet distinct de celui créé dans la méthode.

Explication du code B

En revanche, le code B transmet la référence myFoo comme argument à la méthode createFoo. Au sein de la méthode, un nouvel objet Foo est créé et attribué au paramètre foo. Par la suite, foo est affecté à a, qui est une variable locale dans la méthode. Cette réaffectation modifie effectivement la référence locale foo, et non la référence d'origine myFoo.

Exemple de clarté

Pour illustrer les concepts, considérons la classe suivante :

public class Foo {
   private String attribute;

   public void setAttribute(String attribute) {
      this.attribute = attribute;
   }
}

Classe principale :

public class Main {
   public static void main(String[] args) {
      Foo f = new Foo("f");
      changeReference(f); // Attempt to change reference
      modifyReference(f); // Attempt to modify object attribute
   }

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

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

Après que la méthode principale crée une instance de Foo et l'attribue à f, il appelle changeReference, qui tente de réaffecter la référence a à un objet différent. Cependant, cela ne modifie pas la référence f.

Au contraire, modifierReference modifie l'attribut de l'objet référencé par c, qui est le même objet que f. Cela démontre que le passage de référence crée une copie de la référence, et non de l'objet lui-même.

Conclusion

L'approche de passage par valeur de Java garantit l'immuabilité de l'objet en protégeant les objets d'origine contre les modifications involontaires en dehors de leur portée. Ce principe favorise l'encapsulation et facilite la création de code robuste et prévisible.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!