[débutant]Question théorique sur les objets et leurs références

Bien le bonjour!
Je suis ému, c'est mon premier post!

Venons-en au fait, une immense question me taraude actuellement, et je ne trouve pas de réponse dans mon ouvrage de référence... (il s'agit de "Thinking in Java", excellent bouquin au demeurant)

Supposons que j'instancie une classe

Code:

---

String monString = new String "Blabla";

---

Puis, je crée une autre référence vers cet objet

Code:

---

String monAutreString = monString

---

Les deux "choses" que j'ai crée sont des références vers l'objet en lui-même. Maintenant, j'opère une transformation radicale dans mon objet : par exemple, j'ajoute dix mille caractères à mon String

Code:

---

1 2 3

for(int i=0; i<10000;i++){ monString = monString + "a"; }

---

Là, j'ai un objet qui est très gros il est donc (sans doute) détruit et recrée à un autre endroit de l'espace mémoire, qui contient suffisament de place. (Peut-être que l'exemple du dessus n'est pas pertinent, mais il me semble possible de faire "grossir" la place qu'occupe un objet dans la mémoire, non?) (Je dis ça, parce que je pense qu'un String est une "LinkedList" : chaque caractère pointe vers le suivant, donc, mon exemple ne marche pas, l'objet n'est pas détruit puis recréé)

Je m'égare : une fois que mon objet est devenu énorme et est "délocalisé" dans un autre endroit de la mémoire, comment diable est-ce que mes références sont "averties" de ce changement? Est-ce qu'elle sont averties au moins? Parce que rien dans l'objet n'indique qu'il existe une référence qui pointe vers lui, non?

Pragmatiquement : J'ai un objet qui possède des références un peu partout. Est-ce que ces références pointeront toujours vers le bon objet, malgré tout ce que je peux lui faire subir? Et si oui, pourquoi?

Citation:

---

Envoyé par fezvez

Pragmatiquement : J'ai un objet qui possède des références un peu partout. Est-ce que ces références pointeront toujours vers le bon objet, malgré tout ce que je peux lui faire subir? Et si oui, pourquoi?

---

Avec tes String, tu es tombé justement sur un cas spécial. Une string est immuable, son état ne peut pas changer. Ce qui fait que lorsque tu réalise l'opération suivante :

Code:

---

1 2 3

for(int i=0; i<10000;i++){ monString = monString + "a"; }

---

Tu créé une nouvelle instance a chaque fois. Mais celle d'origine demeure inchangée. Ce qui fait que monAutreString pointe toujours vers "Blabla".

Salut et bienvenue sur les forums ;)


Il faut prendre deux cas bien distinct : les objets immuables (= non modifiables) et les objets muables.



Dans ton exemple String est un objet immuable et ne peut donc pas être modifié après sa création. Lorsque tu fais ceci :

Code:

---

monString = monString + "a";

---

:arrow: Tu crées un nouvel objet en mémoire, et tu l'affectes à la référence monString (donc tu modifies bien la référence également).

Du coup tu as deux objets en mémoire et chacune de tes références pointent vers un de ces objets :

• monString pointe vers la nouvelle chaine "Blablaaaaaaaaaaaaa..."
• monAutreString pointe vers la chaine originale "Blabla".

A noter que ta boucle est très consommateur en mémoire, car pour rajouter les 10000 "a" il va créer autant d'objet temporaire :?


Les objets immuables sont donc fait pour être partagé dans de multiples référence sans que cela ne pose de problème (elles ne peuvent pas être modifié). En fait la "modification" consiste à créer un nouvel objet et l'affecter à une référence, sans que cela n'impacte les autres références.





Prenons maintenant l'objet StringBuffer (ou StringBuilder à partir de Java 5.0, son équivalent non thread-safe), qui est en quelque sorte la version modifiable de String.

Tu aurais donc le code suivant :

Code:

---

1 2 3 4 5 6

StringBuffer monString = new StringBuffer("Blabla"); StringBuffer monAutreString = monString;   for(int i=0; i<10000;i++){ monString.append("a"); }

---

:arrow: La différence vient de l'absence d'affectation ( = ).
On utilise une méthode qui modifie la valeur de l'objet courant (append()), et pendant tous le traitement on ne manipule qu'un seul et unique objet qui est modifié.

Au final on se retrouve donc avec deux références qui pointent vers le même objet.



Si un objet "muable" est modifié, il n'y a pas de mécanisme du langage pour le "signaler" à toutes les références qui pointent vers lui (sauf bien sur si l'objet met en place un système de listener).


a++

Vous cherchez à m'impressionner? :D

Merci beaucoup à vous deux pour vos réponses! (très rapides)

Bon, je m'excuse d'avoir utilisé un si mauvais exemple... mais je comprend très bien ce que vous avez cherché à dire! Quoique ... un dernier petit point reste à éclaircir (si cela ne vous dérange pas, of course!)

Qu'est ce qui détermine le fait qu'on objet soit muable ou pas?

...

J'ai l'impression que ce n'est pas implémenté dans Java, c'est juste une façon de créer une classe :
- Tous les objets sont muables ou presque. Si on veut les modifier, on utilise des méthodes internes, et basta!
- Seuls des objets qui pour être modifiés font appel à un constructeur (c'est le cas du String, même si c'est implicite) sont immuables

Je me trompe?

PS : Je développe sous QtJambi, donc, ce n'est pas trop un problème d'utiliser un listener, je voulais juste savoir si je dois rajouter des "signals" un peu partout, j'ai ma réponse en tout cas!