Discussion :

[bruno_nono]

Bonjour

Par curiosité, histoire de me conforter ce que j'appelle "bonne solution est préférable à mauvaise solution? (Peut-être une question "bête") mais j'aimerais avoir l'explication "informatique" . Dans le premier cas on alloue de l'espace pour deux variables que l'on garde jusqu'à la fin du traitement, dans le second, on alloue et détruit l'allocation d'espace à chaque début/fin de méthode? Ou bien les deux méthodes sont équivalentes?

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
 
public void methode1(){
   /** Mauvaise solution **/
   double i,j;
   Pour Animal de anmiaux
       methode2(animal,i,j)
   Fin Pour
   { traitement } 
   /** Bonne solution **/
   Pour Animal de anmiaux
        methode2(animal)
   Fin Pour
  { traitement }
}
 
public void methode2(Animal animal){
  /** Mauvaise solution **/
   i = this.tester();
   j = this.tester();
   animal.setValeur(i-j)
 /** Bonne solution **/
  double i = this.tester();
  double j = this.tester();
   animal.setValeur(i-j)
}

Si l'on ajoute une variable du type:
dans la méthode 1
X x = new X()
et que dans méthode 2 on exécute x.y() alors on travaille toujours sur le même objet.

Si l'on place X x = new X() dans la méthode 2 alors on crée un objet différent pour chaque appel à la méthode. Vrai ?

Merci beaucoup pour vos éclaircissements !

[thelvin]

Par curiosité, histoire de me conforter ce que j'appelle "bonne solution est préférable à mauvaise solution? (Peut-être une question "bête") mais j'aimerais avoir l'explication "informatique" . Dans le premier cas on alloue de l'espace pour deux variables que l'on garde jusqu'à la fin du traitement, dans le second, on alloue et détruit l'allocation d'espace à chaque début/fin de méthode? Ou bien les deux méthodes sont équivalentes?

Je ne comprends pas quelle différence tu essaies de faire entre les deux. Ça compile pas, on va dire que c'est normal. Mais ton intention n'est pas claire, donc je peux pas trop imaginer ce que tu as en tête.

Si l'on ajoute une variable du type:
dans la méthode 1
X x = new X()
et que dans méthode 2 on exécute x.y() alors on travaille toujours sur le même objet.

Si l'on place X x = new X() dans la méthode 2 alors on crée un objet différent pour chaque appel à la méthode. Vrai ?

Vrai. Donc si tu as besoin de créer un nouvel objet à chaque appel de méthode, solution 2.
Si tu as besoin d'utiliser le même objet à chaque appel de méthode, solution 1.

Si les deux peuvent faire l'affaire, il s'agit de choisir un compromis entre performance et clarté.
- Si c'est plus "clair" en termes de lisibilité, de ne pas créer un objet avant d'appeler des méthodes qui le prennent en paramètre, il faut voir si créer cet objet à chaque appel est une opération lourde. Si non, pourquoi s'embêter, au fond ?
- À l'inverse, si c'est pas clair d'appeler des méthodes sans préciser en paramètre sur quel objet elles se fondent, ou si créer l'objet à chaque fois serait trop lourd, dans ce cas il vaut mieux créer l'objet dans l'appelant, et le passer en paramètre à chaque fois.

[bruno_nono]

Je ne comprends pas quelle différence tu essaies de faire entre les deux. Ça compile pas, on va dire que c'est normal. Mais ton intention n'est pas claire, donc je peux pas trop imaginer ce que tu as en tête.

C'était surtout par rapport à l'utilisation de la mémoire: en gros faire
100 fois double x est-il plus gros qu'une fois double x.
Les deux sont identiques au final à priori. Du coup, c'était juste par question de "règles java". Qu'est-ce qui est le plus joli ?

Ok pour le new.

[verbose]

La JVM effectue des optimisations lors de la compilation à la volée.

Par conséquent, faire ceci :

Code :

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

1
2
3
4
5
 
int var;
for (int i = 0; i < 100; i++) {
    var = i;
}

n'apporte rien par rapport à ceci :

Code :

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

1
2
3
4
 
for (int i = 0; i < 100; i++) {
    int var = i;
}