Discussion :

[speedster]

Bonjour,

Il me semble qu'en Java, tous les paramètres sont passés par valeur excepté les références qui sont passées par adresse.

J'ai la méthode suivante :

Code :

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

1
2
3
4
5
private Participant removeParticipant(Utilisateur utilisateur, Participant participant) {
...
participant = ...
return ...
}

Avant d'appeler cette méthode, je déclare le participant :

Code :

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

1
2
Participant participant = null;
... = removeParticipant(utilisateur, participant);

En faisant cela, j'espérais récupérer le participant modifié à l'intérieur de la méthode mais il n'en est rien. Celui-ci est toujours nul
Je procède de cette façon car la méthode retourne déjà un participant et je souhaite en retourner deux.

Edit: S'il n'est pas possible de procéder de cette façon, j'utiliserais un tableau comme type de retour de la méthode.

[Nicolas_75]

Bonjour,

Ce que tu dis me parait normal. Ma compréhension est la suivante...

Quand un objet est en paramètre d'un appel de méthode, sa référence est passée par valeur à la méthode.

Même si ce n'est pas extrêment précis, dans le but de comprendre, disons que, lorsqu'on fait :
Participant p = new Participant();
p se voit affecté de l'endroit de la mémoire, disons 135674 (même si ce n'est pas le bon format) où le nouvel objet a été créé.

Quand tu appelles removeParticipant(p), c'est 135674 qui est passé à la méthode. Deux cas peuvent donc se produire, selon le contenu de removeParticipant.

(1) Si removeParticipant agit sur le contenu de p, par exemple par un
p.changeContent();
alors p sera bien modifié dans son emplacement mémoire 135674 (pour simplifier). Pas besoin de faire un return. Cf. exemple ListeParticipants1 ci-dessous.

(2) Si removeParticipant remplace p par un nouvel objet, avec un p = new..., alors ce n'est pas pareil. p se verra affecter d'un nouvel emplacement mémoire, disons 989889. Il n'est pas possible de le récupérer en-dehors de la méthode sans return, puisque la référence de p est passée par valeur. Un return est donc indispensable pour récupérer le nouveau p. Cf. exemple ListeParticipants2 ci-dessous.

J'espère que mes propos ne choqueront pas les puristes. Merci aux réactions qui permettront d'améliorer cette explication, qui se voulait simplificatrice.

Nicolas

Exemple 1

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
// appeler le fichier ListeParticipants1.java
 
class Participant {
 
    private int participantNumber;
 
    public Participant(int number) {
        this.participantNumber = number;
    }
 
    public void setNumber(int number) {
        this.participantNumber = number;
    }
 
    public int getNumber() {
        return this.participantNumber;
    }
}
 
public class ListeParticipants1 {
 
    private void removeParticipant(Participant participant) {
        participant.setNumber(5);
    }
 
    public static void main(String[] args) {
        ListeParticipants1 liste = new ListeParticipants1();
        Participant p = new Participant(2);
        System.out.println("p est créé et est initialisé avec un champ à 2");
        System.out.println("avant remove, p.participantNumber = "+p.getNumber());
        liste.removeParticipant(p);
        System.out.println("liste.removeParticipant(p)");
        System.out.println("où, dans removeParticipant, on trouve : participant.setNumber(5);");
        System.out.println("après remove,p.participantNumber = "+p.getNumber());
    }
}

Sortie :

p est créé et est initialisé avec un champ à 2
avant remove, p.participantNumber = 2
liste.removeParticipant(p)
où, dans removeParticipant, on trouve : participant.setNumber(5);
après remove,p.participantNumber = 5

Exemple 2

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
// appeler le fichier ListeParticipants2.java
 
class Participant {
 
    private int participantNumber;
 
    public Participant(int number) {
        this.participantNumber = number;
    }
 
    public void setNumber(int number) {
        this.participantNumber = number;
    }
 
    public int getNumber() {
        return this.participantNumber;
    }
}
 
public class ListeParticipants2 {
 
    private Participant removeParticipant(Participant participant) {
        participant = new Participant(5);
        return participant;
    }
 
    public static void main(String[] args) {
        ListeParticipants2 liste = new ListeParticipants2();
        Participant p = new Participant(2);
        System.out.println("p est créé et son champ est initialisé à 2");
        System.out.println("avant remove, p.participantNumber = "+p.getNumber());
        Participant p2 = liste.removeParticipant(p);
        System.out.println("p2 = liste.removeParticipant(p)");
        System.out.println("où, dans removeParticipant, on trouve : participant = new Participant(5); return participant;");
        System.out.println("après remove,p.participantNumber = "+p.getNumber()+" : c'est toujours 2");
        System.out.println("En revanche, p2.participantNumber = "+p2.getNumber());
    }
}

Sortie :

p est créé et son champ est initialisé à 2
avant remove, p.participantNumber = 2
p2 = liste.removeParticipant(p)
où, dans removeParticipant, on trouve : participant = new Participant(5); return participant;
après remove,p.participantNumber = 2 : c'est toujours 2
En revanche, p2.participantNumber = 5

[speedster]

Merci.

Cela confirme en effet ce que je pensais.