Une analyse approfondie du passage des paramètres de méthode dans la programmation Java

Avant de lire cet article, en fonction de votre propre expérience et compréhension, vous pouvez d'abord réfléchir et choisir la méthode de transmission des paramètres des fonctions Java :
A Est-elle transmise par valeur ?
B. Passé par référence ?
C. En partie par valeur et en partie par référence ?
La bonne réponse ne sera pas encore annoncée ici. Nous utiliserons un exemple simple pour laisser chacun trouver la réponse par lui-même :
1. Définissez d'abord un type Valeur

public static class Value {
  private String value = "value";
  public String getValue() { return value; }
  public void setValue(String value) { this.value = value; }
}

.

2. Écrivez deux fonctions newValue et modifierValue : newValue pointera le paramètre d'entrée vers un nouvel objet, et modifierValue appellera la méthode setValue du paramètre d'entrée pour modifier la valeur de l'objet.

public static void newValue(Value value) {
  value = new Value();
  value.setValue("new value");
  System.out.println("In newValue, HashCode = " + value.hashCode() + ", value = " + value.getValue());
}
    
public static void modifyValue(Value value) {
  value.setValue("new value");
  System.out.println("In modifyValue, HashCode = " + value.hashCode() + ", value = " + value.getValue());
}

3. Code de test simple

public static void main(String[] args) {
  Value value1 = new Value();
  System.out.println("Before modify, HashCode = " + value1.hashCode() + ", value = " + value1.getValue());
  // 将value1指向新的Value对象
  newValue(value1);
  System.out.println("After modify, HashCode = " + value1.hashCode() + ", value = " + value1.getValue() + "\n");
  Value value2 = new Value();
  System.out.println("Before modify, HashCode = " + value2.hashCode() + ", value = " + value2.getValue());
  // 使用object的set方法，修改对象的内部值
  modifyValue(value2);
  System.out.println("After modify, HashCode = " + value2.hashCode() + ", value = " + value2.getValue());
}

4. Journal des résultats d'exécution :

Before modify, HashCode = 12677476, value = value
In newValue, HashCode = 33263331, value = new value
After modify, HashCode = 12677476, value = value
  
Before modify, HashCode = 6413875, value = value
In modifyValue, HashCode = 6413875, value = new value
After modify, HashCode = 6413875, value = new value

<🎜 > 5. Analyse des résultats :

Le code ci-dessus est un modèle de programmation très courant : définir | save | obtenir une valeur ou un objet en périphérie, passer l'objet en paramètre dans une méthode et modifier les propriétés de l'objet dans le méthode., Comportement. Cependant, les méthodes de modification des deux méthodes newValue et modifierValue sont différentes. Une fois la méthode appelée, l'objet est très différent de l'extérieur ! Comment comprendre cette différence ? Passons d'abord en revue les concepts de passage par valeur et de passage par référence :
* Le passage par valeur signifie que lorsqu'un paramètre est passé à une fonction, la fonction reçoit une copie de la valeur d'origine. Ainsi, si la fonction modifie le paramètre, seule la copie est modifiée, tandis que la valeur d'origine reste inchangée.
* Le passage par référence signifie que lorsqu'un argument est passé à une fonction, la fonction reçoit l'adresse mémoire de la valeur d'origine, pas une copie de la valeur. Par conséquent, si la fonction modifie le paramètre, la valeur originale du paramètre (dans le code appelant en dehors du bloc fonction) change également.
Bonne réponse : A——Les fonctions Java transmettent les paramètres par valeur !
Analyser le journal :
* Dans la première sortie du journal, le paramètre value1 est modifié pour pointer vers le nouvel objet à l'intérieur de la méthode newValue, et le hashCode et la valeur du nouvel objet sont affichés, mais après avoir sauté de le domaine de la méthode newValue, dans la méthode principale Il n'y a aucun changement dans la valeur1, ce qui est cohérent avec la définition et les caractéristiques du passage par valeur ; si elle est passée par référence, la valeur1 devrait changer après l'appel de la méthode newValue(Value value) ; .
* Dans la deuxième sortie du journal, value2 effectue une opération setValue dans la méthode modifierValue. Le hashCode reste inchangé mais la valeur est modifiée après avoir quitté le domaine de la méthode modifierValue, value2 change dans la méthode principale. Les personnes qui ont utilisé C peuvent facilement comprendre ce phénomène comme suit : passer des paramètres de fonction par référence ! Parce que c'est très similaire au passage par référence en C ! Mais c’est justement là que l’on risque le plus de tomber dans des malentendus !
Le principe derrière les différents phénomènes dans les deux logs est que le langage Java transmet les paramètres par valeur et les objets par référence ; les objets exploités en Java sont en fait des références aux objets opérationnels, et l'objet lui-même est stocké dans " Heap ", tandis que la "référence" de l'objet est stockée dans un registre ou "pile".
Le pseudo-code décrit la différence entre la méthode newValue et la méthode modifierValue :

newValue{
  Value_ref2 = value_ref1;  // 按值传入引用value_ref1，得到value_ref1的副本
  value_obj2 = new Value();  // value_obj2被创建、初始化在“堆“中
  value_ref2 -> value_obj2;  // value_ref2 指向value_obj2
value_ref2 ->value_obj2.setValue(“xxx”); // value_obj2 的value被修改
printValueObj2();      // 此处打印的是obj2的值
}
modifyValue{
  Value_ref2 = value_ref1;  // 按值传入引用value_ref1，得到value_ref1的副本
value_ref2 ->value_obj1.setValue(“xxx”); // value_obj1 的value被修改
printValueObj1();      // 此处打印的是obj1的值
}

Assez clair ! Lorsque value1_ref1 est transmis à la fonction en tant que paramètre, une copie de value1_ref2 est d'abord copiée pour être utilisée dans le domaine de fonction. À ce stade, les deux références pointent vers le même code value_obj dans la fonction newObject [value = new Value(); ] En fait, value1_ref1 pointe vers un nouvel objet value_obj2 ; les opérations set après cela sont toutes des opérations sur le nouvel objet ; la fonction modifierValue exploite directement value_obj1 via la méthode set, qui est différente de la fonction newValue.

Passer les paramètres par valeur

Lors de l'appel d'une méthode, vous devez fournir des paramètres, et vous devez les fournir dans l'ordre spécifié dans la liste des paramètres.
Par exemple, la méthode suivante imprime un message n fois de suite :

public static void nPrintln(String message, int n) {
 for (int i = 0; i < n; i++)
  System.out.println(message);
}

Exemple

L'exemple suivant démontre l'effet du passage par valeur.
Ce programme crée une méthode utilisée pour échanger deux variables.

public class TestPassByValue {
 
  public static void main(String[] args) {
   int num1 = 1;
   int num2 = 2;
 
   System.out.println("Before swap method, num1 is " +
             num1 + " and num2 is " + num2);
 
   // 调用swap方法
   swap(num1, num2);
   System.out.println("After swap method, num1 is " +
             num1 + " and num2 is " + num2);
  }
  /** 交换两个变量的方法 */
  public static void swap(int n1, int n2) {
   System.out.println("\tInside the swap method");
   System.out.println("\t\tBefore swapping n1 is " + n1
              + " n2 is " + n2);
   // 交换 n1 与 n2的值
   int temp = n1;
   n1 = n2;
   n2 = temp;
 
   System.out.println("\t\tAfter swapping n1 is " + n1
              + " n2 is " + n2);
  }
}

L'exemple de compilation et d'exécution des résultats ci-dessus est le suivant :

Before swap method, num1 is 1 and num2 is 2
    Inside the swap method
        Before swapping n1 is 1 n2 is 2
        After swapping n1 is 2 n2 is 1
After swap method, num1 is 1 and num2 is 2

Pass La méthode swap est appelée avec deux paramètres. Fait intéressant, les valeurs des paramètres réels ne changent pas après l'appel de la méthode.

Pour une analyse plus approfondie du passage de paramètres des méthodes dans la programmation Java, veuillez faire attention au site Web PHP chinois !