Confus, que Java utilise l'appel par valeur ou l'appel par référence lorsqu'une référence d'objet est passée?
public class program1{
public static void main(String args[]){
Java.util.Vector vc=new Java.util.Vector();
vc.add("111");
vc.add("222");
functioncall(vc);
vc.add("333");
System.out.println(vc);
}
public static void functioncall(Java.util.Vector vc){
vc=null;
}
}
Le résultat du programme ci-dessus est [111,222,333]. mais, lorsque j'exécute le programme suivant, la sortie est [333]. Confus lorsque nous transmettons une référence, comment cela fonctionne-t-il, qu'il s'agisse d'un appel par valeur ou d'un appel par référence? et pourquoi
public class program1{
public static void main(String args[]){
Java.util.Vector vc=new Java.util.Vector();
vc.add("111");
vc.add("222");
functioncall(vc);
vc.add("333");
System.out.println(vc);
}
public static void functioncall(Java.util.Vector vc){
vc.removeAllElements();
}
}
Il passe la valeur de la référence.
Pour voler sans vergogne une analogie que j'ai vue postée ici il y a quelque temps, imaginez que chaque identifiant que vous utilisez est un morceau de papier avec une adresse écrite dessus. L'adresse pointe vers une maison.
Vous pouvez changer la maison (par exemple, en ajoutant des objets au vecteur ou en l'effaçant), mais vous tenez toujours le même morceau de papier et l'adresse vous emmène toujours dans la même maison.
Si vous définissez le vecteur sur null, vous ne faites qu'effacer l'adresse.
Cet article l'explique plus en détail.
C'est appel par valeur. Dans les deux cas, vous mettez valeur de référence à référence dans l'argument de la méthode qui est local référence de méthode.
Vous passez vc comme copie de référence (toujours). Ensuite, en faisant vc = null; Ou vc = new Vector(), il vous suffit de modifier la référence à partir de l'attribut local vc et il est donc normal que le principal ne change pas.
Java et C est toujours appeler par valeur. Le terme appel par référence s'applique strictement au C++ où nous utilisons l'opérateur & dans l'argument formel. Dans le cas de références d'objet, les références sont copiées de l'argument réel vers l'argument formel.
Passer par valeur dans Java signifie passer une copie de la valeur à passer. Passer par référence dans Java signifie passer l'adresse elle-même. Dans Java les arguments sont toujours passés par valeur. Java ne prend en charge que le passage par valeur).
Avec les objets Java, la référence d'objet elle-même est transmise par valeur et donc la référence d'origine et la copie des paramètres se réfèrent toutes deux au même objet Java. Java sont également passées par valeur.
Le langage de programmation Java utilise toujours l'appel par valeur. En Java, tous les paramètres des méthodes sont appelés par valeur ou transmis par valeur. Cay S. Horstmann et Garry Cornell ont mentionné dans leur très célèbre livre "Core Java Volume - I Fundamentals") que le langage de programmation Java Java utilise toujours l'appel par valeur) . Cela signifie que la méthode obtient une copie de toutes les valeurs de paramètre et qu'elle ne peut pas modifier le contenu des variables de paramètre qui lui sont transmises. Java utilise deux types de paramètres de méthode:
- Types primitifs Java
- Références d'objets Java
Il semble très simple et simple lorsque vous expérimentez le passage de types primitifs à une méthode, mais devient obscur lorsqu'il s'agit de passer des objets à une méthode. Fait intéressant, lorsqu'une référence d'objet est passée à une méthode, la méthode obtient une copie de la référence d'objet, et l'original et la copie formelle se réfèrent au même objet, par conséquent, à partir de la méthode, l'état d'un paramètre d'objet peut être modifié .
L'article suivant explique bien Appel par valeur et appel par référence .
Java utilise des références d'objet. L'argument est la valeur de référence. Il s'agit donc d'un appel par valeur, où valeur est une référence pour les objets.
vc est une nouvelle variable qui contient la référence du vecteur utilisé pour appeler la méthode. Le changer en null n'affecte pas le vecteur d'origine car cette référence est une copie de la référence du vecteur d'origine.
Mais comme il s'agit d'une référence au vecteur d'origine, toute modification du vecteur change en fait le vecteur d'origine. Donc Java utilise toujours l'appel par valeur, ici la valeur se trouve être une référence.
Avec Java "passer par référence", la référence elle-même est passée par valeur.
Vous ne pouvez donc pas modifier la référence elle-même, mais vous pouvez modifier l'objet pointé par la référence.
Ainsi, votre appel removeAll agit sur le Vector afin que vous voyiez les résultats. Cependant, si vous modifiez la référence elle-même comme:
vc = null
ou,
vc = new Vector();
Ces modifications pointent vers un nouvel objet (ou null), donc toute modification ultérieure ne sera pas reflétée dans l'objet dans main
Java fonctionne avec le "concept Call by Value". Si sa pile et son tas sont visualisés alors Java essaie de trouver les valeurs de n'importe quelle variable dans l'espace de travail local, si ce n'est pas trouvé dans local alors il essaie de trouver dans l'objet qui est dans le tas.
Exemple
class Foo
{
int x;
public void call(int x)
{
x++;
}
public static void main(String[] args)
{
Foo foo = new Foo();
foo.x = 5;
System.out.println(foo.x);
foo.call(foo.x);
System.out.println(foo.x);
}
}
La sortie du programme ci-dessus serait: 5, 5 Desciption: Dans la méthode principale, la valeur de x est assignée 5 sur la référence de "foo: Dans la méthode d'appel, il y a une variable locale nommée" x "(passée comme argument) dans l'espace de travail. La valeur ne serait modifiée que dans son espace de travail. Lorsque le contrôle de cette fonction revient à la méthode principale. Dans l'espace de travail principal, la valeur de "x" est toujours de 5.
Exemple
class Foo
{
int x;
public void call(int y)
{
x++;
}
public static void main(String[] args)
{
Foo foo = new Foo();
foo.x = 5;
System.out.println(foo.x);
foo.call(foo.x);
System.out.println(foo.x);
}
}
Le résultat du programme ci-dessus serait: 5, 6
Desciption: Dans la méthode principale, la valeur de x est assignée 5 sur la référence de "foo: Dans la méthode d'appel, il n'y a pas de variable locale nommée" x "(passée comme argument) dans l'espace de travail. Donc Java le trouve dans la référence par laquelle la fonction "call" a été appelée et la valeur de "x" est là 5, la méthode d'appel incrémente sa valeur à "6" pour que sa valeur soit modifiée en référence c'est-à-dire "foo". lorsque le contrôle de cette fonction revient à la méthode principale. Maintenant, dans la zone de travail principale, la valeur de "x" est 6 car ici nous avons imprimé "x" sur la référence foo.
J'espère que cela vous aidera à clarifier vos concepts.
Cordialement, Sushil Jain
Pass-by-value
Le paramètre réel (ou expression d'argument) est entièrement évalué et la valeur résultante est copiée dans un emplacement utilisé pour contenir la valeur du paramètre formel pendant l'exécution de la méthode/fonction. Cet emplacement est généralement un morceau de mémoire sur la pile d'exécution de l'application (c'est ainsi que Java le gère), mais d'autres langages pourraient choisir le stockage des paramètres différemment.
Pass-by-reference Le paramètre formel agit simplement comme un alias pour le paramètre réel. Chaque fois que la méthode/fonction utilise le paramètre formel (pour la lecture ou l'écriture), elle utilise en fait le paramètre réel. Java est strictement pass-by-value