arguments inout ?

Bonjour,
Je n'ai pas une grande expérience de JAVA, comme va le montrer ma question de newbie : Je souhaite faire une méthode qui prend en arguments un certain nombre de trucs, et les modifie. Evidemment je souhaite que mes modifications persistent quand je sort de ma méthode.
En C++ j'aurais passé ces arguments en référrence avec le "&". Je constate que le "&" n'existe pas en java, ni les "inout" du style ada.

Les arguments sont ils inout par défaut ? (après un petit test, ca semble être le cas pour un objet d'une classe que j'ai défini, mais pas pour un simple int par exemple)

Quelle est la manière propre de faire ?

Tu peux construire un objet spécifique qui contient comme attributs tout ce que tu veux modifier. Tu peux faire des méthodes get/set pour ces attributs afin de pouvoir y accéder et les modifier.

Mais en général, cela dépend de ce que tu veux concevoir. En tout cas, si tu veux modifier un paramètre d'une méthode, tu peux le faire uniquement si c'est un objet. Tu ne peux ainsi pas modifier la référence passée en paramètre d'une méthode :

Code:

---

1 2 3 4 5 6

public void truc(Object obj){ ... obj = new Object(); // Interdit !!! ... }

---

Mais tu peux tout à fait modifier l'OBJET pointé par cette référence.

oui mais par exemple, dans un cas du style :

Code:

---

1 2 3 4 5 6 7

MaMethode(int MonInt, Bidule MonBidule) { ... MonInt ++; MonBidule.Intattribut++; ... }

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11

public static void main(String args[]){ ... int I=0; Bidule MonBidule = new Bidule(); MaMethode(I,MonBidule); ... // MonBidule a bien été modifié sans que je ne spécifie explicitement // que je le passait à MaMethode par référrence plutot que par copie   // I n'a pas été modifié ! Lui est passé par copie et non par référrence ! }

---

Alors "tout" est passé par référrence, mais pas le int par exemple. Quels sont les autres choses qui ne sont pas passées automatiquement par référrence ? Peut on forcer ces choses à être passées par référrence ?

les types primitifs sont passés par valeur et les objets par reference, c'est aussi simple que cela. Si tu souhaite que tes types primitifs soient modifiés, encapsule les dans un objet (classes Integer, Double, Float et autres) : depuis la version 1.5 de java tu dispose de l'autoboxing qui te permettra d'eviter certaines lourdeur d'ecriture

Citation:

---

Envoyé par leyee

les types primitifs sont passés par valeur et les objets par reference, c'est aussi simple que cela

---

En fait, ce n'est pas tout à fait le cas mais bon, pour simplifier, on peut (presque) voir la chose comme ça.

Citation:

---

Envoyé par leyee

Si tu souhaite que tes types primitifs soient modifiés, encapsule les dans un objet (classes Integer, Double, Float et autres) : depuis la version 1.5 de java tu dispose de l'autoboxing qui te permettra d'eviter certaines lourdeur d'ecriture

---

Ca par contre, c'est faux, tu ne peux pas utiliser les classes wrappers prédéfinies dans Java pour faire ça, car celles-ci sont inaltérables (cad qu'une fois une instance d'une de ces classes créée, on ne peux plus en modifier la valeur autrement qu'en lui affectant une nouvelle référence (donc à créer un nouvelle instance de cette classe), il n'y a pas de méthode setXXX).

Pour que des types primitifs puissent être effectivement être modifiés par l'appel d'une méthode, il faut effectivement les encapsuler mais surtout pas dans un objet Wrapper prédéfini dans Java. Il faut créer un objet perso où tu as une variable d'instance du type que tu veux et définir une méthode d'altération afin de pouvoir en modifier la valeur dans une méthode quelconque. Cet objet constituera également un wrapper, mais sera altérable.

Dit avec du code ça donne ça :

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 38

//un classe enveloppe qui va permettre de pouvoir modifier une variable int dans une méthode quelconque public class MyIntWrapper{     private int myValue;   public MyInt(int myValue){ this.myValue = myValue; }   public int getMyValue(){ return myValue; }   public void setMyValue(int myValue){ this.myValue = myValue; }   }   //Pour déclarer une instance de cette classe on ferait : MyIntWrapper wrapper = new MyIntWrapper(5);   //maintenant exemple d'une méthode d'une classe quelconque modifiant la valeur d'un objet MyIntWrapper     public MyOtherClass{   public static void addOne(MyIntWrapper wrapper){ wrapper.setMyValue(getMyValue()+1) } }   //exemple d'utilisation MyIntWrapper wrapper = new MyIntWrapper(5); MyOtherClass.addOne(wrapper); System.out.println(wrapper.getValue); //renvoie 6

---

En espérant être clair... ;)

Merci pour la precision : j'ai eu un doute lorsque j'ai ecrit et j'ai testé et effectivement il faut non pas utiliser les classes Integer et cie qui sont immuables mais des objets faits maison

Et si tu bosse en Java 5 ou sup au lieu de ceci :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public class MyIntWrapper{     private int myValue;   public MyInt(int myValue){ this.myValue = myValue; }   public int getMyValue(){ return myValue; }   public void setMyValue(int myValue){ this.myValue = myValue; }   }

---

Tu utilise ceci :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public class Wrapper<X>{     private X myValue;   public Wrapper(X value){ this.myValue = value; }   public X getValue(){ return myValue; }   public X void setValue(X value){ this.myValue = value; }   }

---

Que tu utilise

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

// Sur un entier Wrapper<Integer> wrapInt = new Wrapper<Integer>(5);   // Sur une chaine Wrapper<String> wrapString = new Wrapper<String>("Hello World");   // Sur une autre classe Immuable   MaClasseImmuable immuable = new MaClasseImmuable("Champ1", new Date()); Wrapper<MaClasseImmuable> wrapImmuable = new Wrapper<MaClasseImmuable>(immuable);

---

Ca permet de pas devoir refaire de classe pour chaque type comme ca :)