Passage par référence en java

Version imprimable

Bonjour,

Code:

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
 
public class c_test {
 
    public c_test() {
    }
 
    public void function1(Integer v){
        v +=1;
        System.out.println("function1...........   "+v+"  ....................");
    }
 
    public void function2(Integer v){
        v +=10;
        System.out.println("function2...........   "+v+"  ....................");
    }
 
 
    public static void main(String[] args){
        c_test C = new c_test();
 
        Integer v;
        v=0;
 
        System.out.println("1 = "+v);
        C.function1(v);
        System.out.println("2 = "+v);
        C.function2(v);
        System.out.println("3 = "+v);
    }
}

ceci me donne le résultat

Code:

1
2
3
4
5
1 = 0
function1...........   1  ....................
2 = 0
function2...........   10  ....................
3 = 0

je chercher à faire un passage par référence à la variable v, qu'est-ce qui est erroné dans mon code qui fait que ceci ne marche pas ??

Merci bcp

09/12/2009, 16h11
Uther
Le problème viens du fait que Integer n'est pas un type primitif, mais un objet immuable : il n'existe aucune méthode permettant de modifier sa valeur.

Jusqu'en java 1.4, on ne pouvait pas faire le moindre calcul avec les objets.

Depuis java 1.5 et l'arrivée de l'autoBoxing/autoUnboxing, les Objets représentant un type(Integer/Byte/Long...) sont automatiquement convertis en leur type primitif équivalent, mais ce n'est jamais que du sucre syntaxique : v étant immuable, si tu lui affecte une valeur, il est créé un nouvel objet.

Par exemple dans ton code:
Code:

1 2 3 v += 1 // équivaut en fait a un v = new Integer(v.intValue()++);
L'objet auquel v faisait référence n'est donc pas modifié.
09/12/2009, 16h25
psycho_xn
Citation:
Envoyé par Uther

Le problème viens du fait que Integer n'est pas un type primitif, mais un objet immuable : il n'existe aucune méthode permettant de modifier sa valeur.

Jusqu'en java 1.4, on ne pouvait pas faire le moindre calcul avec les objets.

Depuis java 1.5 et l'arrivée de l'autoBoxing/autoUnboxing, les Objets représentant un type(Integer/Byte/Long...) sont automatiquement convertis en leur type primitif équivalent, mais ce n'est jamais que du sucre syntaxique : v étant immuable, si tu lui affecte une valeur, il est créé un nouvel objet.

Par exemple dans ton code:

Code:

1 2 3 v += 1 // équivaut en fait a un v = new Integer(v.intValue()++);

L'objet auquel v faisait référence n'est donc pas modifié.
en gros il n'est pas possible de garder la valeur modifiée d'une variable en dehors de la fonction.

j'ai essayé avec un type StringBuffer et la valeur est bel et bien sauvegardée, je conclus donc que le problème vient des types. une idée sur les types qui permettent le référencement des objets ?? j'utiliseré le StrinBuffer au lieu du String, mais qu'en est-il de mon Integer ??

Les objets Integer,Short, Byte, String, ... sont immuables : leur valeur interne est initialisée dans le constructeur et aucune de leur méthodes ne permet de la modifier.

StringBuffer est en quelque sorte une version mutable de la classe String. Comme String, elle contient en interne une chaine de caractères, mais ses méthodes permettent de la modifier.

Il n'y a pas de version mutable des type primitifs numériques en java. Il te faudra les créer toi même.
par exemple:

Code:

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
public class c_test{
 
    public c_test() {
    }
 
    public void function1(MutableInteger v){
        v.put( v.get() + 1);
        System.out.println("function1...........   "+v+"  ....................");
    }
 
    public void function2(MutableInteger v){
        v.put( v.get() + 10);
        System.out.println("function2...........   "+v+"  ....................");
    }
 
 
    public static void main(String[] args){
        Testd C = new Testd();
 
        MutableInteger v = new MutableInteger(0);
 
        System.out.println("1 = "+v);
        C.function1(v);
        System.out.println("2 = "+v);
        C.function2(v);
        System.out.println("3 = "+v);
    }
}
class MutableInteger{
    private int i;
 
    public int get() {return this.i;}
    public void put(int i) {this.i = i;}
    public MutableInteger(int i) {this.i = i;}
    @Override public String toString() { return new Integer(i).toString();}
 
}

09/12/2009, 17h34
thelvin
Citation:

Envoyé par Uther

Il n'y a pas de version muttable des type primitifs numériques en java. Il te faudra les créer toi même.

En fait, il est possible de détourner les AtomicInteger et consorts pour faire exactement ça : ça marche aussi.
Code:

1 2 3 4 AtomicInteger i = new AtomicInteger(1); System.out.println(i.get()); i.set(2); System.out.println(i.get());
À aucun moment on n'a créé de nouvel objet AtomicInteger, pourtant la valeur du premier change quand on lui demande.
09/12/2009, 17h47
psycho_xn
Citation:
Envoyé par thelvin

En fait, il est possible de détourner les AtomicInteger et consorts pour faire exactement ça : ça marche aussi.

Code:

1 2 3 4 AtomicInteger i = new AtomicInteger(1); System.out.println(i.get()); i.set(2); System.out.println(i.get());

À aucun moment on n'a créé de nouvel objet AtomicInteger, pourtant la valeur du premier change quand on lui demande.
Merci pour la piste, je vais voir si ça me fera l'affaire avec les Integer.
je pense que g v utiliser StringBuffer au lieu du String,
AtomicInteger au lieu du Integer,
et pour les Short et char ??
09/12/2009, 18h27
Uther

Citation:

Envoyé par thelvin

En fait, il est possible de détourner les AtomicInteger et consorts pour faire exactement ça : ça marche aussi.

En effet. Je n'avais pas pensé à utiliser l'AtomicInteger parce que comme tu le dis, c'est un usage détourné. Cette classe est conçue pour résoudre certaines problématiques de concurrence.
L'utilisation de la classe à cette fin ne devrait cependant pas poser de problème, sauf peut-être des performance légèrement moindre dans certains cas.

Citation:

Envoyé par psycho_xn

je pense que g v utiliser StringBuffer au lieu du String,
AtomicInteger au lieu du Integer,
et pour les Short et char ??

Il n'existe pas de AtomicShort ou AtomicChar, mais tu peux évidement les stoquer dans un AtomicInteger.
Sinon tu peux coder des MutableShort et MutableChar sur le modèle de mon exemple.
09/12/2009, 18h32
psycho_xn

Citation:

Envoyé par Uther

Sinon tu peux coder des MutableShort et MutableChar sur le modèle de mon exemple.

si j'adopte la méthode pour coder mes propres types, je serais dans l'obligation de n'utiliser que ces types là. j'ai juste un soucis côté taille de la mémoire occupée par ces types, est-ce qu'il seront toujours codés sur la même taille ??

En ce qui concerne le passage par référence, en général on le fait via un tableau à une dimension.
Code:

1 2 3 4 5 6 7 /** * @param entierInOut tableau d'un entier, modifié. */ void monPlusPlus( int[] entierInOut){ entierInOut[0]++; }
Perso j'aime pas, ca prête à confusion

Il y a aussi la possibilité d'utiliser une classe pointeur, je trouve ca déjà plus "propre" (car générique et explicite).
Code:

1 2 3 4 5 6 7 8 class Pointeur<Type>{ private Type data; Pointeur(){ this.data = null; } Pointeur(Type data){ this.data = data; } Type get(){ return data; } void set(Type data){ this.data = data; } }
Enfin, dans ton cas on peut effectivement utiliser le MutableInteger de Uther dans la mesure où il utilise un type primitif et est donc plus performant (si il y a un gros besoin sur ce niveau là)

Si il n'y a qu'une valeur à renvoyer, fait une fonction au lieu d'une procédure.

En général, si l'on a besoin de passer un truc par référence, il se situe déjà dans un autre objet, et c'est donc celui-la que l'on passe en paramètre.

dans le code donné, la méthode la plus propre, c'est de retourner la nouvelle valeur. Ca marche pas si il y en a plusieurs, mais dans le cas présent c'est la méthode la plus propre:

Code:

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
public class c_test {
 
    public c_test() {
    }
 
    public Integer function1(Integer v){
        v +=1;
        System.out.println("function1...........   "+v+"  ....................");
        return v;
    }
 
    public Integer function2(Integer v){
        v +=10;
        System.out.println("function2...........   "+v+"  ....................");
        return v;
    }
 
 
    public static void main(String[] args){
        c_test C = new c_test();
 
        Integer v;
        v=0;
 
        System.out.println("1 = "+v);
        v=C.function1(v);
        System.out.println("2 = "+v);
        v=C.function2(v);
        System.out.println("3 = "+v);
    }
}

10/12/2009, 15h16
psycho_xn

Citation:

Envoyé par tchize_

dans le code donné, la méthode la plus propre, c'est de retourner la nouvelle valeur. Ca marche pas si il y en a plusieurs, mais dans le cas présent c'est la méthode la plus propre:

il s'agissait juste d'un simple exemple, mais j'ai des cas où j'ai besoin de faire référence à plusieurs variables
10/12/2009, 15h26
ep31

Citation:

Envoyé par psycho_xn

il s'agissait juste d'un simple exemple, mais j'ai des cas où j'ai besoin de faire référence à plusieurs variables

Bonjour, il te suffirait de stocker tes Integer et consorts dans une collection, la passer en paramètre de ta méthode et de modifier les valeurs des différents objets en modifiant donc ta collection avec les nouveaux éléments