Discussion :

[Lamy20]

Bonjour tout le monde;

D'après ce que j'ai lu java utilise le passe de paramètre par copie de référence, par exemple pour passer un objet en paramètre à une méthode elle lui passe une copie de la référence et non pas la référence, est ce qu'il y a qlq qui sait la raison de cela?

merci à l'avance

[BSans]

Quelle est la finalité de la question ?

J'avais fait un petit test pour voir si ça pouvait fonctionner comme le passage de pointeurs en C, et il s'est avéré que oui, mais dans le cas du passage d'objets :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
public class Test {
 
    public void maSuperFonction (MonAutreTest t) {
        t.setX(1);
        t.setY(2);
    }
 
    public static void main (String[] args) {
 
        MonAutreTest t2 = new MonAutreTest();
 
        System.out.println("---------------");
        System.out.println("x: "+t2.getX()+", y: "+t2.getY()); // affiche x: 0, y: 0
        test.maSuperFonction (t2);
        System.out.println("x: "+t2.getX()+", y: "+t2.getY()); // affiche x: 1, y: 2
        System.out.println("---------------");
 
    }
}
 
 
class MonAutreTest {
    private int x, y;
 
    public void setX (int x) {
        this.x = x;
    }
 
    public int getX () {
        return x;
    }
 
    public void setY (int y) {
        this.y = y;
    }
 
    public int getY () {
        return y;
    }
}

Mais je suis pas certain qu'il s'agisse de ta question ^^°

[nouknouk]

une copie de la référence et non pas la référence

Dans le sens C++ien, quand on passe une référence, on passe en fait un pointeur. C'est bien entendu une copie du pointeur original, pas l'adresse qui pointe sur le pointeur (ie. un pointeur de pointeur).

C'est la même chose en Java:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
    public static void maFonctionChangeRef(Object obj) {
        Object initialFuncObj = obj;
        obj = new Object();
 
        System.out.println("initialFuncObj == obj : "+(initialFuncObj ==obj));
    }
    public static void main(String[] args) {
 
        Object oMain = new Object();
        Object o1 = oMain;
        maFonctionChangeRef(o1);
        System.out.println("o1 == oMain : "+ (oMain == o1) );
    }

Te retournera:

- 'false' pour , (initialFuncObj == obj), normal on a affecté un nouvel object à obj.

- 'true' pour (o1 == oMain) car ce qu'a modifié maFonctionChangeRef() est la référence obj, qui est locale à la fonction. Pas la référence qu'on lui a passé en paramètre au moment de l'appel (à savoir o1 dans le contexte du main).

Ca me paraît plutôt logique. Car au final o1 fait partie du contexte du main, et est donc sous sa responsabilité. Ce n'est pas au code maFonctionChangeRef de tripoter ce vers quoi pointe o1.

Si toi tu veux pouvoir modifier o1, rien ne t'empêche de faire que maFonctionChangeRef() retourne une référence vers un Object.
C'est alors dans le main que tu affecteras o1 = maFonctionChangeRef(o1).

Exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
    public static Object maFonctionChangeRef(Object obj) {
        Object initialFuncObj = obj;
        obj = new Object();
 
        System.out.println("initialFuncObj == obj : "+(initialFuncObj ==obj));
 
        return obj ;
    }
    public static void main(String[] args) {
 
        Object oMain = new Object();
        Object o1 = oMain;
        o1 = maFonctionChangeRef(o1);
        System.out.println("o1 == oMain : "+ (oMain == o1) );
    }

Ce code, évidemment, te retournera deux fois 'false'.

Mais je suis pas certain qu'il s'agisse de ta question ^^°

Idem