Différence?: 1. Le transfert de valeur créera une copie, tandis que le transfert de référence ne crée pas de copie?; 2. Dans le transfert de valeur, l'objet d'origine ne peut pas être modifié dans la fonction, mais dans le transfert de référence, l'objet d'origine peut être modifié dans la fonction. Le passage par valeur signifie que lors de l'appel d'une fonction, une copie des paramètres réels est transmise à la fonction, de sorte que si les paramètres sont modifiés dans la fonction, les paramètres réels ne seront pas affectés, tandis que le passage par référence signifie que lors de l'appel de la fonction ; fonction, une copie des paramètres réels sera transmise à la fonction. L'adresse est transmise directement à la fonction, donc les modifications apportées aux paramètres de la fonction affecteront les paramètres réels.

L'environnement d'exploitation de ce tutoriel : système windows7, version java8, ordinateur DELL G3.

Paramètres réels et formels

Nous savons tous que les paramètres peuvent être définis lors de la définition d'une méthode en Java. Par exemple, la méthode main en Java, public static void main(String[ ] args), les arguments ici sont des paramètres. Les paramètres sont divisés en paramètres formels et paramètres réels dans les langages de programmation.

• Paramètres formels?: sont les paramètres utilisés lors de la définition du nom de la fonction et du corps de la fonction. Le but est de recevoir les paramètres transmis lors de l'appel de la fonction.

• Paramètres réels?: Lors de l'appel d'une fonction paramétrée, il existe une relation de transfert de données entre la fonction appelante et la fonction appelée. Lors de l'appel d'une fonction dans la fonction appelante, les paramètres entre parenthèses après le nom de la fonction sont appelés "paramètres réels"

Un exemple simple?:

public static void main( String[ ] args) {
ParamTest pt = new ParamTest();
pt.sout( "Hollis");//實際參數(shù)為Hollis
}
public void sout( String name) {/!形式參數(shù)為name
system.out.println(name);
}

Les paramètres réels sont ceux qui sont réellement passés lors de l'appel d'une méthode paramétrée, et Formel les paramètres sont des paramètres utilisés pour recevoir le contenu des paramètres réels.

Passage par valeur et passage par référence

Comme mentionné ci-dessus, lorsque nous appelons une fonction paramétrée, les paramètres réels seront transmis aux paramètres formels. Cependant, dans les langages de programmation, il existe deux cas de transfert dans ce processus de transfert, à savoir le transfert par valeur et le transfert par référence. Voyons comment le passage par valeur et le passage par référence sont définis et distingués dans les langages de programmation.

Transmission de valeur signifie copier les paramètres réels et les transmettre à la fonction lors de l'appel de la fonction, de sorte que si les paramètres sont modifiés dans la fonction, les paramètres réels ne seront pas affectés.
Pass by reference signifie transmettre l'adresse des paramètres réels directement à la fonction lors de l'appel de la fonction. Ensuite, les modifications apportées aux paramètres dans la fonction affecteront les paramètres réels.

Avec les concepts ci-dessus, vous pouvez ensuite écrire du code et le pratiquer pour voir s'il s'agit d'un passage de valeur ou d'un passage de référence en Java. Ainsi, le morceau de code le plus simple est sorti?:

public static void main( String[] args) {
     ParamTest pt = new ParamTest();
    int i = 10;
    pt.pass(i);
    System.out.println( "print in main , i is " +i);
}
public void pass(int j){
    j = 20;
    system.out.println( "print in pass , j is " + j);
}

Dans le code ci-dessus, nous avons la valeur de. le paramètre j est modifié dans la méthode pass, puis la valeur du paramètre est imprimée respectivement dans la méthode pass et la méthode principale. Le résultat de sortie est le suivant?:

print in pass , j is 20
print in main , i is 10

On peut voir que la modification de la valeur de i à l'intérieur de la méthode pass ne change pas la valeur du paramètre réel i. Ainsi, selon la définition ci-dessus, quelqu'un est arrivé à la conclusion : le passage de méthode Java est un passage de valeur.
Cependant, certaines personnes ont vite soulevé des questions (haha, alors ne tirez pas de conclusions hatives.). Ensuite, ils retireront le code suivant :

public static void main(String[ ] args) {
    ParamTest pt = new ParamTest();
    User hollis = new User();
    hollis.setName( "Hollis");
    hollis.setGender("Male");
    pt.pass(hollis);
    system.out.println( "print in main , user is " + hollis);}public void pass(User user) {
    user.setName( "hollischuang");
    System.out.println( "print in pass , user is " + user);}

est également une méthode pass, et la valeur du paramètre est également modifiée au sein de la méthode pass. Le résultat de sortie est le suivant?:

print in pass , user is User{name='hollischuang', gender='Male '}
print in main , user is User{name='hollischuang' , gender='Male '}

Une fois la méthode pass exécutée, la valeur du paramètre réel est modifiée. Selon la définition du passage par référence ci-dessus, la valeur du paramètre réel n'est pas appelée. en passant par référence ? Par conséquent, sur la base des deux morceaux de code ci-dessus, quelqu'un est arrivé à une nouvelle conclusion : dans les méthodes Java, lors du passage de types ordinaires, il est passé par valeur, et lors du passage de types d'objet, il est passé par référence.
Cependant, cette affirmation est toujours fausse. Si vous ne me croyez pas, jetez un ?il au transfert de paramètres suivant où le type de paramètre est un objet?:

public static void main( string[] args) {
    ParamTest pt = new ParamTest();
    string name = "Hollis";
    pt.pass(name ) ;
    System.out.println( "print in main , name is " + name);
}
public void pass(string name) {
    name = "hollischuang";
    system.out.println( "print in pass , name is " + name);
}

Le résultat de sortie du code ci-dessus est

print in pass , name is hollischuangprint in main , name is Hollis

Quelle est l'explication?: un objet est également transmis, mais le La valeur du paramètre d'origine n'est pas modifiée. Est-il passé ? Les objets sont à nouveau passés par valeur ?

Transmission de valeur en Java

Ci-dessus, nous avons donné trois exemples, mais les résultats sont également différents. et même de nombreux programmeurs avancés ont des doutes sur Java. Il y a une raison de confusion sur la transmission des types. En fait, ce que je veux vous dire, c'est que le concept ci-dessus n'est pas faux, mais il y a un problème avec l'exemple de code. Allez, laissez-moi vous exposer les points clés du concept, puis vous donner quelques exemples vraiment pertinents.

Transmission de valeur signifie copier les paramètres réels et les transmettre à la fonction lors de l'appel de la fonction, de sorte que si les paramètres sont modifiés dans la fonction, les paramètres réels ne seront pas affectés.
Passage par référence signifie transmettre l'adresse des paramètres réels directement à la fonction lors de l'appel de la fonction. Ensuite, la modification des paramètres dans la fonction affectera les paramètres réels.

Alors, laissez-moi vous résumer les points clés de la différence entre le passage de valeur et le passage de référence.

我們上面看過的幾個pass的例子中，都只關(guān)注了實際參數(shù)內(nèi)容是否有改變。如傳遞的是User對象，我們試著改變他的name屬性的值，然后檢查是否有改變。其實，在實驗方法上就錯了，當(dāng)然得到的結(jié)論也就有問題了。

為什么說實驗方法錯了呢?這里我們來舉一個形象的例子。再來深入理解一下值傳遞和引用傳遞，然后你就知道為啥錯了。

你有一把鑰匙，當(dāng)你的朋友想要去你家的時候，如果你直接把你的鑰匙給他了，這就是引用傳遞。這種情況下，如果他對這把鑰匙做了什么事情，比如他在鑰匙上刻下了自己名字，那么這把鑰匙還給你的時候，你自己的鑰匙上也會多出他刻的名字。

你有一把鑰匙，當(dāng)你的朋友想要去你家的時候，你復(fù)刻了一把新鑰匙給他，自己的還在自己手里，這就是值傳遞。這種情況下，他對這把鑰匙做什么都不會影響你手里的這把鑰匙。

但是，不管上面那種情況，你的朋友拿著你給他的鑰匙，進到你的家里，把你家的電視砸了。那你說你會不會受到影響?而我們在pass方法中，改變user對象的name屬性的值的時候，不就是在“砸電視”么。

還拿上面的一個例子來舉例，我們真正的改變參數(shù)，看看會發(fā)生什么?

public static void main(String[ ] args){
    ParamTest pt = new ParamTest();
    User hollis = new User();
    hollis.setName( "Hollis");
    hollis.setGender("Male" );
    pt.pass(hollis);
    system.out.println("print in main , user is " + hollis);
    public void pass(User user) {
        user = new User();
        user.setName( "hollischuang");
        user.setGender( "Male");
        system.out.println( "print in pass , user is " + user);

上面的代碼中，我們在pass方法中，改變了user對象，輸出結(jié)果如下:

print in pass , user is User{name='hollischuang ' , gender='Male '}
print in main , user is User{name='Hollis', gender= 'Male '}

我們來畫一張圖，看一下整個過程中發(fā)生了什么，然后我再告訴你，為啥Java中只有值傳遞。

稍微解釋下這張圖，當(dāng)我們在main中創(chuàng)建一個User對象的時候，在堆中開辟一塊內(nèi)存，其中保存了name和gender等數(shù)據(jù)。然后hollis持有該內(nèi)存的地址ex123456(圖1)。當(dāng)嘗試調(diào)用pass方法，并且hollis作為實際參數(shù)傳遞給形式參數(shù)user的時候，會把這個地址ex123456交給user，這時，user也指向了這個地址(圖2)。然后在pass方法內(nèi)對參數(shù)進行修改的時候，即user = newUser();，會重新開辟一塊 eX456789的內(nèi)存，賦值給user。后面對user的任何修改都不會改變內(nèi)存eX123456的內(nèi)容(圖3)。

上面這種傳遞是什么傳遞?肯定不是引用傳遞，如果是引用傳遞的話，在user=new User()的時候，實際參數(shù)的引用也應(yīng)該改為指向eX456789，但是實際上并沒有。

通過概念我們也能知道，這里是把實際參數(shù)的引用的地址復(fù)制了一份，傳遞給了形式參數(shù)。所以，上面的參數(shù)其實是值傳遞，把實參對象引用的地址當(dāng)做值傳遞給了形式參數(shù)。

我們再來回顧下之前的那個“砸電視”的例子，看那個例子中的傳遞過程發(fā)生了什么。

同樣的，在參數(shù)傳遞的過程中，實際參數(shù)的地址eX1213456被拷貝給了形參，只是，在這個方法中，并沒有對形參本身進行修改，而是修改的形參持有的地址中存儲的內(nèi)容。

所以，值傳遞和引用傳遞的區(qū)別并不是傳遞的內(nèi)容。而是實參到底有沒有被復(fù)制一份給形參。在判斷實參內(nèi)容有沒有受影響的時候，要看傳的的是什么，如果你傳遞的是個地址，那么就看這個地址的變化會不會有影響，而不是看地址指向的對象的變化。就像鑰匙和房子的關(guān)系。

那么，既然這樣，為啥上面同樣是傳遞對象，傳遞的String對象和User對象的表現(xiàn)結(jié)果不一樣呢?我們在pass方法中使用name = “hollischuang”;試著去更改name的值，陰差陽錯的直接改變了name的引用的地址。因為這段代碼，會new一個String，在把引用交給name，即等價于name =new String(“hollischuang”);。而原來的那個”Hollis”字符串還是由實參持有著的，所以，并沒有修改到實際參數(shù)的值。

所以說，Java中其實還是值傳遞的，只不過對于對象參數(shù)，值的內(nèi)容是對象的引用。

總結(jié)

無論是值傳遞還是引用傳遞，其實都是一種求值策略(Evaluation strategy)。在求值策略中，還有一種叫做按共享傳遞。其實Java中的參數(shù)傳遞嚴(yán)格意義上說應(yīng)該是按共享傳遞。

Le passage par partage signifie que lorsqu'une fonction est appelée, une copie de l'adresse du paramètre réel est transmise à la fonction (si le paramètre réel est sur la pile, la valeur est copiée directement). Lorsque vous utilisez des paramètres dans une fonction, vous devez copier l'adresse pour trouver la valeur spécifique avant d'opérer. Si la valeur est sur la pile, comme il s'agit d'une copie directe de la valeur, les opérations sur les paramètres de la fonction n'affecteront pas les variables externes. Si la copie originale est l'adresse de la valeur d'origine dans le tas, vous devez alors trouver l'emplacement correspondant dans le tas en fonction de l'adresse avant d'effectuer l'opération. étant donné qu'une copie de l'adresse est transmise, l'opération sur la valeur dans la fonction est visible par la variable externe.

Pour faire simple, le transfert en Java se fait par valeur, et cette valeur est en fait une référence à un objet.
Le passage par partage n'est en réalité qu'un cas particulier de passage par valeur. On peut donc dire que passer en Java, c'est passer par partage, ou que passer en Java, c'est passer par valeur.

Ainsi, les paramètres de fonctionnement à l'intérieur de la fonction n'affecteront pas les variables externes. Si la copie originale est l'adresse de la valeur d'origine dans le tas, vous devez alors trouver l'emplacement correspondant dans le tas en fonction de l'adresse avant d'effectuer l'opération. étant donné qu'une copie de l'adresse est transmise, l'opération sur la valeur dans la fonction est visible par la variable externe.

Pour faire simple, le transfert en Java se fait par valeur, et cette valeur est en fait une référence à un objet.

Et le passage par partage n'est en fait qu'un cas particulier de passage par valeur. On peut donc dire que passer en Java, c'est passer par partage, ou que passer en Java, c'est passer par valeur.

Pour plus de connaissances liées à la programmation, veuillez visiter?: Enseignement de la programmation?! !

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!