Discussion :

[Ryadus]

Bonjour;
Soit une classe A comportant un membre String title, le constructeur A(String t) initialise ce membre avec la chaîne t, vaut-il mieux écrire:

Code :

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

1
2
3
4
5
public class A {
    private title;
        A(String t){
              title = t;
              ...

ou bien

Code :

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

1
2
3
4
5
public class A {
    private title;
    A(String t){
          title = new String(t);
          ...

Quel est la différence entre les deux?
Les deux solutions sont elles strictement équivalentes pour la suite de l'exécution du programme ?

Merci

[soad]

dans le 1er cas tu donne à ta variable title la référence de ton objet String t... Cela veux dire que tu auras un seule objet String en mémoire avec 2 variables qui pointe dessus.

et dans le 2ème cas tu créer un nouvelle objet en mémoire. Tu auras donc title et t qui pointe chacun sur un objet différent

[adiGuba]

Salut,



Dans le premier cas tu utilises la même référence de String, donc le même objet.

Dans le second tu crées un nouvel objet en tout point identique, et tu te retrouve donc avec deux objets identiques en mémoire.

Les deux solutions sont elles strictement équivalentes pour la suite de l'exécution du programme ?

Pour un objet String c'est équivalent mais il est préférable d'utiliser la première solution (afin d'éviter de créer un objet en mémoire en plus).


Mais en vérité cela dépend du type de ton objet...


En effet si la valeur de la String pouvait être modifié (par exemple par une méthode setValue()), la valeur de l'attribut de ta classe A peut être modifié ultérieurement sans passé par une eventuelle méthode setTitle() :

Code :

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

1
2
3
4
String title = "titre";
A a = new A(title);
 
title.setValue("TITRE");

Dans le premier cas cela pose un problème car ta classe A ne peut pas effectué des traitements suite à la modification du titre (par exemple pour mettre à jours l'affichage) car elle ne peut pas savoir qu'il a été modifié...
Dans le second cas il n'y a pas de problème car le titre de l'objet A est une copie qui n'est pas modifié...


Le second cas que tu présentes est la solution qui est employé par le C++ pour éviter ce type de problème (les passages de paramètres se font automatiquement par copie), mais cela implique l'écriture de constrcuteur de copie et la création de nombreux objets temporaire... Exemple (solution 2) :

Code :

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

A a = new A("titre");

Tu te retrouves avec deux chaine "titre" alloué (une avant l'appel du constructeur, et une dans le constrcuteur), dont une qui sera libéré par le Garbage Collector car elle n'est plus utilisé...

Globalement cela implique la création de plusieurs copies d'objets tout au long de ton programme....



Mais, en Java on utilise généralement la première solution malgré le problème cité plus haut...

Pourquoi ? Tout simplement parce qu'on utilise des classes immuable. C'est à dire qu'une fois qu'une instance est créée, il est impossible de modifier sa valeur. Le seul moyen est de créer une nouvelle instance (c'est pourquoi la plupart des méthodes de la classe String renvoyent une nouvelle String au lieu de la modifier directement).

C'est le cas de la classe String, Integer, Double, etc...


Cela permet d'éviter des effets de bord puisqu'il est impossible de modifier la valeur de l'instance... Et on plus on évite un grand nombre de copie d'objet "inutile" qui peuvent vite s'avérer très lourd (d'ailleurs même en C++ on utiliser des références vers des objets immuable plutôt que les constructeurs de copies lorsque c'est possible).





Par contre, lorsque une classe n'est pas immuable, il peut être préférable de faire une copie si on veut éviter de tels problèmes...


a++

[Ryadus]

merci
excellente réponse