passage variable par référence

Bonjour, voici une question que je n'ai jamais eu à me poser et qui pourtant paraît très bête : le passage d'une variable, un int par exemple, par référence et non par valeur. :roll:

Si on veut modifier la valeur d'un entier grâce à une méthode, on peut faire un return bien sûr, mais si il y a plusieurs entiers, ... cela reste trop limité.
De plus si on veut qu'une variable est sa valeur toujours attachée à celle d'une autre variable, cela ne marche plus.
Je n'ai quasiment pas fait de C, mais en C avec un pointeur c'est immédiat. Alors en java, faut-il créer une classe exprès pour gérer ce cas, pour faire un passage par référence d'une classe contenant cet entier, ou peut-on simplement associé la valeur d'un entier à un autre.

Je donne un exemple (c'est pas du java, c'est juste pour comprendre) :
x=0
y=x // donc y = 0
x=2
//alors y=2 aussi
C'est ce que j'aimerai obtenir.

J'ai fait un exemple qui marche avec une classe qui enveloppe un entier. Mais c'est un peu lourd juste pour faire pointer un entier sur la valeur d'un autre.
L'exemple est en fichier joint.

Merci d'avance :P

++ et bonne prog

PS : enfin dernière question, avec le système que j'emploie, à cette ligne ci :

Origin o = wrapper1.getO();
wrapper2.setO(o);
o=null;

Pourquoi si je la remplace par cela, ça ne marche plus : wrapper2.getO()=wrapper1.getO();

Je récupère l'instance o de wrapper2 que je fais pointer sur le même objet (Origin) que l'instance o de wrapper1 ??? non ?

Mais j'ai une erreur : the left-hand side of an assignment must be a variable. (sous eclipse)

Une question à la fois SVP nous sommes tout de même le dimanche de Pâques !! Il faut faire des pauses de temps en temps !

Bon, en java, les valeurs primitives (donc les int) se passent par valeur, tandis que les objets se passent par référence. C'est tout.

Si tu veux passer une valeur primitive par référence, il faut la mettre dans un objet, et si tu veux passer un objet par valeur il faut le mettre dans des valeurs primitives (par exemple).

Et s'il y a plusieurs entiers ?... Alors, il faut Penser en Java.

2 règles de base de java:

1) tous les arguments des méthodes sont passés par valeur.
2) les variables peuvents soit contenir des types de base (boolean, int, etc), soit une référence vers un type Object.

donc, dans ton cas, si tu veux modifier un contenu, tu ne peux que passer par valeur la référence vers un objet. Tu pourra modifier les contenu de l'objet et l'appelant y trouvera les nouvelles valeur, mais tu ne pourra pas changer d'instance d'objet (car alors tu change la référence, et cette référence t'as été passée par valeur).

En règle générale, si une méthode doit renvoyer des valeurs, on utilise return. Et si t'as une méthodes qui doit modifier plusieurs valeurs liées entre elle, il serait probablement bon de prendre ces valeur et cette méthode et de faire un objet de l'ensemble. Si les valeurs sont liées, elles sont de bonnes candidates pour etre dans un même objet.

Merci beaucoup de vos explications.

Si je comprends bien, ma manière de le faire ici est donc bonne ?

Le problème du return, est que ça retourne une valeur, mais ça n'associe pas la valeur d'une primitive à une autre automatiquement.
Donc si je comprends bien, je dois encapsuler mes primitives dans un objet, et passer les instances de ces objets en paramètre d'une méthode, afin de modifier l'objet sur lequel elles pointent.
En clair il n'y a pas vraiment plus court que le code que j'ai mis en exemple .

Merci beaucoup

++ ;)

PS : désolé de poser deux questions à la fois :oops:, mais je ne vois aps pourquoi cela ne marche pas : wrapper2.getO()=wrapper1.getO();

si, il y a plus court, utiliser le return :/

De plus, dans ton cas, tu fais:

Code:

---

1 2 3 4 5 6

Enveloppeur wrapper1 = new Enveloppeur(5); Enveloppeur wrapper2 = new Enveloppeur(); Origin o = wrapper1.getO(); wrapper2.setO(o); wrapper1.setI(6);

---

Fonctionnellemen, le code suivant serait le même:

Code:

---

1 2 3 4

Origin o = new Origin(5); Origin o2 = o; o.setOrigin(i);

---

La classe enveloppeur en moins :/

Merci, je me doutais bien que la classe enveloppeur était inutile, mais c'est parce que je mettais en lien avec l'application que je voulais en faire. :P

Sinon pour le return je ne vois toujours pas : le return renvoie une valeur oui, mais si je change ma valeur trois fois, je dois appeler trois fois ma méthode qui contient le return, alors que là, j'ai rien à faire : o.setOrigin(i) autant de fois que je veux, et o2 est modifié automatiquement.

++

avec les référence, (en C par exemple) ce n'est pas possible non plus, accessoirement.

Sis je fait ceci en C

Code:

---

1 2 3 4 5

int j,k;   j =3; k =j; methode(&j);

---

même si methode modifie j, il ne modifiera pas k. Et lier deux int, j'ai du mal à en voir l'intérêt :)

Oui, je crois que je comprends :)

Sinon l'intérêt de lier deux int ensembles, c'était de faire un arbre hiérarchique entre plusieurs objets 3D. Par exemple une lumière est attachée à une lampe qui est attachée à un bureau. Ainsi, si le bureau se déplace, la lampe et la lumière bouge avec. J'avais donc pensé à lier l'origine de ma lampe à l'origine de mon bureau. Par exemple si l'origine de la lampe est (x,y,z) et celle du bureau est (x',y',z'), avoir un truc du genre x=x'+5,y=y'-3,...
Ainsi si je modifie (x',y',z') en faisant bouger mon bureau, la lampe a ses coordonnées actualisées automatiquement, sans avoir besoin d'appeler une méthode qui modifie les coordonnées à chaque renouvellement de la position du bureau.

++ 8-)

PS : quel est le problème dans cette instruction ? :oops: wrapper2.getO()=wrapper1.getO();

tu peux pas assigner. Si tu voulais comparer, faut un double == :)