Analyser le concept de types de référence en Java

1. Qu'est-ce qu'un type référence
Un type référence pointe vers un objet, pas une valeur primitive La variable pointant vers l'objet est une variable de référence.
En Java, tous les autres types à l'exception des types de données de base sont des types de données de référence. Les classes que vous définissez sont toutes des types de référence et peuvent être utilisées comme des types de base.
Les exemples sont les suivants :

    public class MyDate {
        private int day = 8;
        private int month = 8;
        private int year = 2008;
        private MyDate(int day, int month, int year){...}
        public void print(){...}
    }
    public class TestMyDate {
        public static void main(String args[]) {
            //这个today变量就是一个引用类型的变量
            MyDate today = new MyDate(23, 7, 2008);
        }
    }

2. Affectation des types de référence
Dans le langage de programmation Java, utilisez un type d'une classe La variable déclarée est désignée comme type référence car elle fait référence à un type non primitif, ce qui a des implications importantes pour l'affectation. Le code suivant :

    int x = 7;
    int y = x;
    String s = "Hello";
    String t = s;

Quatre variables sont créées : deux types primitifs int et deux types référence String. La valeur de x est 7, et cette valeur est copiée dans y ; x et y sont deux variables indépendantes et les modifications ultérieures dans l'une n'ont aucun effet sur l'autre. Quant aux variables s et t, il n'existe qu'un seul objet String, qui contient le texte "Bonjour", et s et t font référence à cet objet unique.

Si la variable t est redéfinie comme t="World" alors un nouvel objet World est créé, et t fait référence à cet objet.

3. La différence entre le passage par valeur et le passage par référence
 1) Passage par valeur
signifie que lorsque la méthode est appelée, les paramètres passés sont passés par copie par valeur. Un exemple est le suivant :

public class TempTest {
    private void test1(int a) {
        // 做点事情
        a++;
    }
   
    public static void main(String args[]) {
        TempTest t = new TempTest();
        int a = 3;
         t.test1(a);//这里传递的参数a就是按值传递。
         System.out.printIn("main方法中的a===" + a);
      }
  }

La caractéristique importante du passage par valeur : ce qui est transmis est une copie de la valeur, ce qui signifie qu'elles ne sont plus pertinentes après le passage. A à la ligne 9 et a à la ligne 2 sont deux variables. Lorsque la valeur de a à la ligne 2 est modifiée, la valeur de a à la ligne 9 reste inchangée, le résultat imprimé est donc 3.
Le a dans la méthode principale est 3
Le a dans la méthode test1 est 4
Nous appelons le a dans la 9ème ligne un paramètre réel, et le a dans la 2ème ligne un paramètre formel pour basic ; data Les modifications apportées au type et aux données de paramètres formels n'affectent pas les données de paramètres réelles.
2) Passage par référence
signifie que lorsque la méthode est appelée, les paramètres passés sont passés par référence. En fait, ce qui est passé est l'adresse de la référence, qui est la mémoire. espace correspondant à l’adresse de la variable.
Les exemples sont les suivants :

public class TempTest {
    private void test1(A a) {
        a.age = 20;
        System.out.printIn("test1方法中的age="+a.age);
    }
    public static void main(String args[]) {
        TempTest t = new TempTest();
        A a = new A();
        a.age = 10;
        t.test1(a);// 这里传递的参数a就是按引用传递
           System.out.printIn("main方法中的age="+a.age);
      }
  }
  classA {
      public int age = 0;
  }

Les résultats d'exécution sont les suivants : age = 20 dans la méthode test1 age = 20 dans la méthode main
Caractéristiques importantes du passage par référence :
Le passage est une référence à la valeur, ce qui signifie qu'avant et après le passage pointent vers la même référence (c'est-à-dire le même espace mémoire).
Si vous souhaitez comprendre correctement le processus de passage par référence, vous devez apprendre à comprendre le processus d'allocation de mémoire. Le diagramme d'allocation de mémoire peut nous aider à comprendre ce processus.
Utilisez l'exemple ci-dessus pour analyser :
(1) Commencez à exécuter, exécutez la ligne 8, créez une instance de A, le diagramme d'allocation de mémoire est le suivant :
a dans la méthode principale

(2), exécutez la ligne 9, modifiez la valeur age dans l'instance A, le schéma d'allocation mémoire est le suivant :
a dans la méthode principale

(3). L'exécution de la ligne 10 consiste à transmettre l'adresse de l'espace mémoire référencée par la variable a dans la méthode principale à la variable a dans la méthode test1 par référence. Attention : ces deux variables a sont complètement différentes, ne vous laissez pas tromper par le même nom, mais elles pointent vers la même instance A. Le diagramme d'allocation de mémoire est le suivant :

(4), exécutez la ligne 3, qui est la méthode test1 La variable a in indique l'âge de l'instance A pour l'affectation. Une fois terminé, le nouveau diagramme de mémoire est formé comme suit :

.

此时A实例的age值的变化是由test1方法引起的。
    （5）、运行第4行，根据此时的内存示意图，输出test1方法中的age=20
    （6）、运行第11行，根据此时的内存示意图，输出main方法中的age=20
    3）对上述例子的改变
    理解了上面的例子，可能有人会问，那么能不能让按照引用传递的值，相互不影响呢？就是test1方法里面的修改不影响到main方法里面的呢？
    方法是在test1方法里面新new一个实例就可以了。改变成下面的例子，其中第3行为新加的：

public class TempTest {
    private void test1(A a) {
        a = new A();// 新加的一行
        a.age = 20;
        System.out.printIn("test1方法中的age="+a.age);
    }
    public static void main(String args[]) {
        TempTest t = new TempTest();
        A a = new A();
         a.age = 10;
        t.test1(a);// 这里传递的参数a就是按引用传递
           System.out.printIn("main方法中的age="+a.age);
      }
  }
  classA {
      public int age = 0;
  }

 运行结果为：test1方法中的age=20  main方法中的age=10
    实现了按引用传递的值传递前与传递后互不影响，还是使用内存示意图来理解一下：
    （1）、运行开始，运行第9行，创建了一个A实例，内存分配示意图如下：

（2）、运行第10行，是修改A实例里面的age的值，运行后内存分配示意图如下：

（3）、运行第11行，是把mian方法中的变量a所引用的内存地址，按引用传递给test1方法中的a变量。请注意：这两个a变量是完全不同的，不要被名称相同所蒙蔽。

（4）、运行第3行，为test1方法中的变量a重新生成了新的A实例，完成后形成的新的内存示意图如下：

（5）、运行第4行，为test1方法中的变量a指向的新的A实例的age进行赋值，完成后形成新的内存示意图如下：

注意：这个时候test1方法中的变量a的age被改变，而main方法中的a变量是没有改变的。
     （6）、运行第5行，根据此时的内存示意图，输出test1方法中的age=20
     （7）、运行第12行，根据此时的内存示意图，输出main方法中的age=10
    说明：
    （1）、“在Java里面参数传递都是按值传递”这句话的意思是：按值传递是传递的值的拷贝，按引用传递其实传递的是引用的地址值，所以统称按值传递。
    （2）、在Java里面只有基本类型和按照下面这种定义方式的String是按值传递，其它的都是按引用传递。就是直接使用双引号定义的字符串方式：String str = "Java快车";

相关文章：

Java四种引用类型的具体介绍

详细比较Java中的基本类型变量和引用类型变量

JavaScript 基本数据类型和引用类型的区别详解

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!