Quelle est la différence entre ces 2 codes:
Code A:
Foo myFoo;
myFoo = createfoo();
où
public Foo createFoo()
{
Foo foo = new Foo();
return foo;
}
Contre. Code B:
Foo myFoo;
createFoo(myFoo);
public void createFoo(Foo foo)
{
Foo f = new Foo();
foo = f;
}
Y a-t-il des différences entre ces 2 codes?
Java transmet toujours les arguments par valeur NON par référence.
Permettez-moi d'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 l'expliquer par étapes:
Déclarer une référence nommée f
de type Foo
et l'affecter à un nouvel objet de type Foo
avec un attribut "f"
.
Foo f = new Foo("f");
Du côté méthode, une référence de type Foo
avec un nom a
est déclarée et elle est initialement affectée à null
.
public static void changeReference(Foo a)
Lorsque vous appelez la méthode changeReference
, la référence a
sera affectée à l'objet qui est passé en argument.
changeReference(f);
Déclarer une référence nommée b
de type Foo
et l'affecter à un nouvel objet de type Foo
avec un attribut "b"
.
Foo b = new Foo("b");
a = b
Réattribue la référence a
PAS f
à l'objet dont son attribut est "b"
.
Lorsque vous appelez la méthode modifyReference(Foo c)
, une référence c
est créée et affectée à l'objet avec l'attribut "f"
.
c.setAttribute("c");
changera l'attribut de l'objet qui référence c
pointe vers lui, et c'est le même objet qui référence f
pointe vers lui.
J'espère que vous comprenez maintenant comment fonctionne le passage d'objets comme arguments dans Java :)
Puisque Java est strictement "pass by value" et même les références aux objets sont passées par valeur le deuxième code ne fonctionnera pas comme prévu. Voir la section "Related" à droite pour nombreux discussions à ce sujet.
Considérez les paramètres de méthode comme leur propre variable déclarations. Si vous deviez remplacer l'appel de méthode par un seul bloc de code, cela ressemble à ceci:
Foo myFoo;
{ //Method call starts here
Foo foo;
foo = myFoo;
Foo f = new Foo();
foo = f;
} //Method call ends here
Même si le paramètre de méthode porte le même nom qu'une autre variable, le paramètre de méthode est toujours sa propre référence unique que seule la méthode connaît. C'est la même chose que l'ingénieur Fouad dit ci-dessus.
Un autre point important que vous devez connaître est le type d'objet que vous passez dans la méthode. que ce soit un objet mutable ou un objet immuable. Si vous passez un objet immuable tel que String, il créera une autre copie et effectuera la modification. Les modifications ne sont pas répercutées sur votre copie d'origine.