Qu’est-ce que le passage de paramètres ? Quelle est son utilité ?

1 Présentation

1. Qu'est-ce que le passage de paramètres ?

Le processus de transmission de données aux paramètres formels lors de l'appel d'une méthode est appelé passage de paramètres. Il existe deux modes de transfert dans les langages de programmation : le transfert par valeur et le transfert par référence. Il faut souligner que les deux méthodes de livraison mentionnées ici ne se limitent pas à celles utilisées en Java, mais sont des méthodes de livraison qui apparaissent dans de nombreux langages de programmation dont Java.

2. Type de variable

En Java, nous appelons les variables pointant vers des variables primitives de données de type de base, et les variables pointant vers des objets appelées une référence. variable.

2. Transmission de valeur

1. Qu'est-ce que la transmission de valeur ?

Transmettez une copie de la variable dans la méthode. Les opérations à l'intérieur et à l'extérieur de la méthode sont isolées. Les opérations sur les variables à l'intérieur de la méthode ne seront pas reflétées dans les variables en dehors de la méthode.

2. Variable d'origine

    public void change(int b) {
        b = 7;
    }

    @Testpublic void testBasic() {int a = 9;
        change(a);
        System.out.println(a);
    }

Sortie réelle : 9

Lors du passage des paramètres, selon les règles de passage des valeurs, la variable b reçoit une copie de a, qui pointe également vers la valeur littérale "9":

Ensuite, à l'intérieur de la méthode, attribuez une valeur de 7 à b, de sorte que b pointe vers 7. Puisque a et b sont deux variables indépendantes, il n'y a pas de relation référence à référence entre eux, et un point fixe sur 9 :

3.String

    public void change(String str01) {
        str01 = "baidu";
    }

    @Testpublic void testString() {
        String str = new String("www.baidu.com");
        change(str);
        System.out.println(str);
    }

Sortie réelle : www.baidu.com

Lors du passage des paramètres, str transmet une copie de lui-même à str01, de sorte que str01 pointe également vers le tas pour stocker l'objet "www.baidu .com":

Attribuez une valeur à str01 à l'intérieur de la méthode, donc que str01 pointe vers le pool de constantes de chaîne de zone de méthode "baidu", str pointe toujours vers "www.baidu.com" dans le tas, str et str01 pointent vers des objets différents et ne s'affectent pas :

Une chose à noter ici : Java conçoit String comme un objet immuable, c'est-à-dire qu'une fois que la valeur littérale contenue dans l'objet String change, Java créera un nouvel objet et pointera la variable vers le nouvel objet.

4.StringBuilder

    public void change(StringBuilder builder01) {
        builder01.append(" World!");
    }

    @Testpublic void testStringBuilder() {
        StringBuilder builder = new StringBuilder("Hello");
        change(builder);
        System.out.println(builder);
    }

Sortie réelle : Bonjour tout le monde !

Une fois le transfert des paramètres terminé, la variable builder01 obtient une copie de la variable builder La copie et la variable d'origine pointent vers le même objet dans le tas :

<.>

À l'intérieur de la méthode, la variable builder ne pointe pas vers un nouvel objet, elle pointe toujours vers le même objet que builder, donc lorsque builder accède au même objet dans le tas, les données changent :

5. Type personnalisé

public class MyInner {public int a;
}public class Test{public void change(MyInner in01) {
        in01.a = 1;
    }

    @Testpublic void testDemain() {
        MyInner in = new MyInner();
        in.a = 9;
        change(in);
        System.out.println(in.a);
    }

}

Sortie réelle : 1

Le processus d'exécution est le même que celui de StringBuilder et ne sera pas décrit à nouveau ici. Apportons quelques modifications au code ci-dessus, comme suit :

public class MyInner {public int a;
}public class Test{public void change(MyInner in01) {
        in01=new MyInner();//使in01指向一个新的对象in01.a = 1;
    }

    @Testpublic void testDemain() {
        MyInner in = new MyInner();
        in.a = 9;
        change(in);
        System.out.println(in.a);
    }

}

实际输出：9

参数传递完成时，in01与in指向同一个对象，in01对对象的操作等同于in对对象的操作，接着在方法内部执行"in01=new MyInner();"，这样in01就指向了一个新的对象，in01所有的操作都与in无关了：

综合以上的运行结果与分析，可知java参数传递方式符合值传递。

 三 引用传递

1.什么是引用传递？

将变量自身的内存地址传入方法中，方法中的变量指向方法外的变量，在方法中对变量的操作就是对方法外变量的操作。

2.自定义类型

public class MyInner {public int a;
}public class Test{public void change(MyInner in01) {
        in01=new MyInner();//使in01指向一个新的对象in01.a = 1;
    }

    @Testpublic void testDemain() {
        MyInner in = new MyInner();
        in.a = 9;
        change(in);
        System.out.println(in.a);
    }

}

实际输出：9

如果采用引用传递，传递完成以后，in01指向in，对in01的操作就是对in的操作，in01指向对象2，那么in也指向对象2，输出1，与实际不符，所以不是采用引用传递。

不再一一分析其他变量类型，分析后可以发现，java在传递参数时采用的不是引用传递，而是值传递。

简单讲，值传递时方法内外是两个拥有同一指向的变量，引用传递时方法内外是同一个变量。

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!