**
Passage de paramètres lors du passage de valeurs Java et du passage de références
**
En Java, le passage de paramètres est divisé en passage de valeur et passage de référence .
Les types de données en Java sont divisés en deux catégories : l'un est un type de référence , également appelé type de classe (tous les types de données composés sauf String, y compris les tableaux, les classes et les interfaces), qui fait référence aux noms de variables des objets créés par la classe , Ce type doit respecter les règles de "passer par référence" lors du passage; l'autre est de type primitif , soit 8 types de base (type d'octet (octet), entier court (court), type entier (int)) , Entier long (long), caractère (char), virgule flottante (float), double précision (double), booléen (booléen)), ce type de données est passé dans l'appel pour se conformer à la règle de "transfert de valeur" de.
Voyons ensuite comment la transmission de paramètres est effectuée par la transmission de valeurs et la transmission de références .
Un, transfert de valeur
Transfert de valeur : lorsque la méthode est appelée, le paramètre réel transfère sa valeur au paramètre formel correspondant. La modification du paramètre formel pendant l'exécution de la méthode n'affecte pas la valeur du paramètre réel.
Tout d'abord, vous pouvez regarder un morceau de code:
package com.yf1020;
public class Student {
public void changeInt(int t) {
t=100;
System.out.println("这里t的值是：" +t);
}
}
Ici, créez d'abord une classe Student, dans cette classe il y a une méthode pour changer la valeur de t.
Ensuite, nous allons créer l'objet et appeler la méthode qu'il contient. Le code est le suivant:
package com.yf1020;
public class Manager {
/*
* 程序运行的入口点
* */
public static void main(String[] arg) {
//创建对象
Student st = new Student();
int i = 1000;
//调用方法 在changeInt中改变i的值
st.changeInt(i);
System.out.println("这里i的值是：" +i);
}
Résultat de sortie:
En sortant le résultat, nous pouvons prouver que le t changé dans la méthode changeInt n'a rien à voir avec i, et le changement de t dans la méthode n'affectera pas la valeur de i dans le code appelant. En fait, nous pouvons également comprendre de cette façon, c'est-à-dire d'abord regarder le programme principal dans la classe principale. Lorsque i est défini sur 1000, la valeur de i est transmise à la méthode changeInt, qui change la valeur de t dans la méthode changeInt, mais cela N'affectera pas la valeur de i dans la classe principale, changez simplement la valeur de t dans la méthode changeInt.
Deux, passer par référence
Passer par référence: également appelée adresse de passe. Lorsque la méthode est appelée, la référence du paramètre réel (adresse et non la valeur du paramètre) est transmise au paramètre formel correspondant dans la méthode. Lors de l'exécution de la méthode, l'opération sur le paramètre formel est en fait l'opération sur le paramètre réel. Le changement de valeur de paramètre affectera la valeur réelle du paramètre.
Avant de comprendre le passage par référence, comprenez d'abord ce qu'est une référence, le code est le suivant:
//创建对象，这里的test1类名是随意命名的，没有什么具体意义的
Student st = new Student();
Ce code peut être décrit comme suit: déclarez d'abord une variable st du type Student, puis pointez le nom de la variable st vers un objet Student nouvellement créé. La variable st est le nom de l'objet nouvellement créé - pas les données d'objet elles-mêmes! ! ! Par exemple, vous êtes un objet étudiant et vous êtes appelé «étudiant A». Lorsque nous utilisons le nom «étudiant A», le «guillemet» est vous, mais votre entité et le nom «étudiant A» ne sont pas la même chose, vous Il s'appelle "Student A" et ce nom fait référence à votre objet.
Regardez un exemple de code pour comprendre immédiatement, comme suit:
Classe d'étudiant:
package com.yf1020;
public class Student {
private String name;
public void setName(String t) {
name = t;
}
public String getName() {
return name;
}
}
Catégorie principale:
package com.yf1020;
public class temp {
public static void main(String[] arg) {
//创建对象
Student st1 = new Student();
st1.setName("第一个");
Student st2 = new Student();
st2.setName("第二个");
Student st3 = new Student();
st3.setName("第三个");
//进行交换
st1 = st2; //将st2的引用值赋给st1；
st2 = st3; //将st3的引用赋值给st2；
st3 = st1; //因为上面已经把st2赋给了st1，此时st1内的引用值是之前st2内的值，所以这个时候相当于将最开始st2的值赋给了st3了。
String name1 = st1.getName();
String name2 = st2.getName();
String name3 = st3.getName();
System.out.println(name1);
System.out.println(name2);
System.out.println(name3);
}
}
Résultat de sortie: A
partir du résultat final, nous pouvons voir que le nom de variable de st3 pointe finalement vers l'objet de st2, c'est-à-dire l'objet dont la valeur de nom est affectée au "second".
De même, lorsque la méthode est appelée, si le paramètre de méthode est un type de référence, ce qui est passé n'est qu'une référence au nom de l'objet, pas à l'objet lui-même! ! ! code montrer comme ci-dessous:
package com.yf1020;
public class Teacher {
public void changeST(Student st) {
String newName = "改名字";
st.setName(newName);
}
public static void main(String[] arg) {
//创建对象
Student st1 = new Student();
//调用前，设定学生的名字
st1.setName("第一个");
Teacher te = new Teacher();
//传入对象引用名：
te.changeST(st1);
String name = st1.getName();
System.out.println("调用后st1的名字其实是："+name);
}
}
Résultat de sortie:
en regardant la valeur de sortie, nous savons que la valeur d'origine est modifiée dans la méthode changeST de l'objet te, c'est-à-dire que lorsque l'appel est effectué, le st1 dans la méthode principale et le nom de la variable st dans le changeST pointent tous vers le même Student Objet! ! !