Discussion :

[BreakMyMind]

Bonjour,
Je suis actuellement en train de programmer une application permettant de rentrer dans postgreSQL diverses informations sur une famille d’accueil à l’aide d’un formulaire mais je me retrouve confrontée à un problème lorsque j’essaye d’ajouter les informations relatives aux contacts.
Voici actuellement ce que peut remplir l’utilisateur :

L’utilisateur peut rentrer 1 ou 2 contact et pour chaque contact il a la possibilité de renseigner plusieurs numéro de portable / fixe / etc.
Je ne pense pas que ce soit important pour ce problème alors je vais passer la manière dont je récupère toutes les informations.
Mon problème se pose lors de la création d’un ContactInfo. Voici la classe :

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
public class ContactInfo {
    private int id_family;
    private String contact_name;
    private ArrayList<String> mobile;
    private ArrayList<String> landline;
    private ArrayList<String> email;
    private ArrayList<String> other_contact;
 
 
    public ContactInfo(int new_id_family, String new_contact_name, ArrayList<String> new_mobile,
            ArrayList<String> new_landline, ArrayList<String> new_email, ArrayList<String> new_other_contact)
    {
        this.id_family = new_id_family;
        this.mobile = new_mobile;
        this.landline = new_landline;
        this.email = new_email;
        this.other_contact = new_other_contact;
        this.contact_name = new_contact_name;
    }
 
//Getter&Setter
}

Je stocke donc les différents numéro/email, dans des ArrayList<String>.
Lorsque je change d’onglet, j’appelle la méthode addContact qui va me créer 1 ou 2 ContactInfo que je stocke dans ArrayList<ContactInfo> new_contact_array. Voici la méthode :

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
private void addContact(Add_Family main_panel) throws SQLException
{
    new_contact_array.clear();
 
    //Pour chaque formulaire
    for(int i=0; i<full_form_hmap_size; i++)
    {
        full_form = full_form_hmap.get(i);
 
        // Pour chaque portable, on récupère le numéro
        mobile_array.clear();
        for(int j=0; j<full_form.getMobile_hmap_size(); j++)
        {
            //Ajoute seulement si il n’y a pas un numéro identique déjà présent dans l’array
            if(!mobile_array.contains(full_form.getMobile_tf_hmap().get(j).getText().replaceAll("\\s","")))
            {
                mobile_array.add(full_form.getMobile_tf_hmap().get(j).getText().replaceAll("\\s",""));
            } else {
                    JOptionPane.showMessageDialog(null,
                    "Vous avez inscrit le même numéro plusieurs fois, il ne sera ajouté qu’une fois."
                            + "\nSi vous vouliez ajouter un autre numéro, vérifiez les informations entrées.",
                    "Invalid Input",
                    JOptionPane.WARNING_MESSAGE);
            }
        }
 
        //Pour chaque fixe, on récupère le numéro
        //Pour chaque email, on récupère l’adresse
        //Pour chaque autre contact, on récupère le nom
 
        //On crée un nouveau ContactInfo avec les informations récupérer
        new_contact = new ContactInfo(
            main_panel.getFamily_id(),
            full_form.getContact_name_tf().getText(),
            mobile_array,
            landline_array,
            email_array,
            other_contact_array
        );
 
        new_contact_array.add(new_contact);
    }
 
    //On ajoute l’array au panel principal
    main_panel.setNew_contact(new_contact_array);
}

Je ne montre que la partie pour récupérer les portables car il s’agit du même code pour les autres champs.
Dans l’exemple, lors de ma première boucle, j’ai donc :

id_family = 1
contact_name = « A Name »
mobile = « 11111111111 », « 22222222222 »
landline = « 33333333333 »
email = « randomemail@test.com »
other_contact = « »

Seulement, quand je rentre dans la boucle pour ajouter le deuxième contact, lorsque je modifie mobile_array, cela me modifie new_contact et new_contact_array. À la fin de la méthode, je me retrouve donc avec deux ContactInfo dans new_contact_array :

ContactInfo 1 :
id_family = 1
contact_name = « A Name »
mobile = « 55555555555 »
landline = « 66666666666 »
email = « »
other_contact = « »

ContactInfo 2 :
id_family = 1
contact_name = « Another One »
mobile = « 55555555555 »
landline = « 66666666666 »
email = « »
other_contact = « »

id_family et contact_name sont donc intactes mais toutes les autres valeurs sont modifiées.
Je pense qu’il doit y avoir un problème de pointeur / référencement, mais je ne m’y connais pas très bien. J’ai fait quelques recherches mais ne comprenant pas vraiment mon problème, j’ai du mal à orienter mes recherches. Pourriez-vous m’aider à résoudre ce problème ou au moins m’indiquer mon erreur pour que je puisse mieux orienter mes recherches ?

Je suis désolée si je suis passée à côté d’une question identique sur le forum. Merci d’avoir lu jusqu’au bout.

[joel.drigo]

Salut,

Tout ça n'est pas très clair. Déjà, si tu nous montrais ce que tu attends comme résultat, pour le comparer à ce que tu obtiens, ce serait mieux. Que veux tu dire par "intactes" ? Pourquoi ça t'étonne que new_contact soit modifié alors qu'à chaque tour de boucle tu fais new_contact = new ContactInfo(/*....*/) : forcément la valeur de new_contact est modifiée dès lors que full_form_hmap_size>0.

Premièrement, si tu as deux contacts dans la liste new_contact_array, c'est probablement parce que full_form_hmap_size vaut 2 et que tu appelles clear() au début de la méthode (ce qui t'évite le cumul, mais qui est étrange pour une méthode appelée add, censée donc ajouter). Ils ont tous les deux le même id_family parce que la source est la même pour les deux (main_panel.getFamily_id()).

Ensuite, le souci est que tu recycles tes instances de listes (comme mobile_array). Il faut que tu crées une nouvelle instance à chaque fois pour avoir une nouvelle liste.

Illustration exemple :

1. 
   
   

   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
   26
   27
   28
   public class ExempleRecyclage {
    
         private List<Integer> list = new ArrayList<>();
    
         public List<Integer> convert(int...array) {
                 list.clear();
                 for(int val : array) {
                      list.add(val);
                 }
                 return list;
         }
    
         public static void main(String[] args) {
    
                    ExempleRecyclage run = new ExempleRecyclage();
    
                    List<Integer> list1 = run.convert(1,2,3);
                    List<Integer> list2 = run.convert(4,5,6);
    
    
                    System.out.println(list1);
                    System.out.println(list2);
    
    
         }
    
    
   }

   Ce programme va afficher :
   

   [4,5,6]
   [4,5,6]

   
   
   
   list1 et list2 référence la même instance de List.
   
   
   
   
2. 
   
   

   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
   26
   public class Exemple {
    
         public List<Integer> convert(int...array) {
                 List<Integer> list = new ArrayList<>();
                 for(int val : array) {
                      list.add(val);
                 }
                 return list;
         }
    
         public static void main(String[] args) {
    
                    Exemple run = new Exemple();
    
                    List<Integer> list1 = run.convert(1,2,3);
                    List<Integer> list2 = run.convert(4,5,6);
    
    
                    System.out.println(list1);
                    System.out.println(list2);
    
    
         }
    
    
   }

   Ce programme va afficher :
   

   [1,2,3]
   [4,5,6]

   
   list1 et list2 référence une instance différente de List.
   
   
   

Du coup, tes full_form_hmap_size contacts ont la même liste de mobiles (la même instance d'ArrayList), ce lui du dernier full_form.

A noter que de manière générale, il vaut mieux déclarer ses variables au plus proche de là où on s'en sert, ce qui évite déjà un certain nombre de ce genre de problème, et aussi les confusions et mélanges. Par exemple, full_form = full_form_hmap.get(i); : ici tu utilises une variable full_form déclarée je ne sais où alors qu'elle devrait être locale à l'itération (on devrait voir son type juste devant son nom).

[BreakMyMind]

Bonjour,
Tout d’abord merci de m’avoir répondu. Je pense globalement avoir compris mes erreurs même si un point reste flou.

Pourquoi ça t'étonne que new_contact soit modifié alors qu'à chaque tour de boucle tu fais new_contact = new ContactInfo(/*....*/)

Je suis surprise que new_contact soit modifié car j’ai justement utilisé new ContactInfo si j’avais utilisé un mutateur j’aurais compris qu’il soit modifié, mais pour moi, utiliser new ContactInfo crée une nouvelle instance. De toute évidence j’ai tort mais dans ce cas je n’arrive pas à comprendre ce que fait new ContactInfo

Que veux tu dire par "intactes" ?

Le résultat que j’attendais était

ContactInfo 1 :
id_family = 1
contact_name = « A Name »
mobile = « 11111111111, 22222222222 »
landline = « 33333333333 »
email = « randomemail@test.com »
other_contact = « »

ContactInfo 2 :
id_family = 1
contact_name = « Another One »
mobile = « 55555555555 »
landline = « 66666666666 »
email = « »
other_contact = « »

tu appelles clear() au début de la méthode (ce qui t'évite le cumul, mais qui est étrange pour une méthode appelée add, censée donc ajouter).

J’appelle clear() au début de ma méthode, car si l’utilisateur décide de revenir sur cet onglet pour faire des modification, je dois effacer le contenu de la liste pour modifier new_contact_array au lieu de rajouter les nouvelles informations à la suite des anciennes. Mais si je crée la liste directement à l'intérieur de ma méthode, je suppose que je n'aurais plus besoin de clear() quoique se soit.

Ensuite, le souci est que tu recycles tes instances de listes (comme mobile_array). Il faut que tu crées une nouvelle instance à chaque fois pour avoir une nouvelle liste.

Je pensais qu’il s’agissait d’une bonne pratique de programmation (je suis encore stagiaire) je pensais simplement qu’il valait mieux réutiliser les listes plutôt que d’en créer de nouvelles (par soucis de mémoire / vitesse d’exécution)

il vaut mieux déclarer ses variables au plus proche de là où on s'en sert

Là encore, je pensais qu’il valait mieux déclarer toute les variables au même endroit, et éviter de les déclarer dans une méthode. Il s’agit de toute évidence de grosses erreurs de débutante de ma part.

Quoi qu’il en soit, j’ai modifié la méthode en remplaçant les clear() de chaque liste par un new ArrayList<>(). Je vais également faire un tour sur toutes mes classes afin de les réécrire en suivant ces conseils.

Merci beaucoup pour le temps que vous m’avez consacré, je récupère à présent les informations que je souhaitais.

[joel.drigo]

Je suis surprise que new_contact soit modifié car j’ai justement utilisé new ContactInfo si j’avais utilisé un mutateur j’aurais compris qu’il soit modifié, mais pour moi, utiliser new ContactInfo crée une nouvelle instance. De toute évidence j’ai tort mais dans ce cas je n’arrive pas à comprendre ce que fait new ContactInfo

J'ai l'impression que tu confonds variable et instance. La notion de mutateur ne concerne que la notion d'instance, pas de variable. On change la valeur d'une variable par affectation, donc par =. Un mutateur change la valeur d'un attribut d'une classe (enfin c'est juste un nom qu'on donne à une méthode pour qualifier ce qu'elle fait) : le mutateur modifie effectivement une variable par affectation, directement ou indirectement.

En bref, quand tu écris :

Code :

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

1
2
3
4
5
6
7
8
class MaClasse {
   private int bidule;
   public void setBidule(int valeur) {
       bidule=valeur;
   }
}
MaClasse truc = new MaClasse();
truc.setBidule(2);

Tu déclares une variable truc dont la valeur est la référence d'un objet de type MaClasse. setBidule() est un mutateur de l'objet, et modifie l'attribut bidule. Il ne faut pas considérer que setBidule mute truc. Dans une conversation, pour simplifier on peut le dire, mais c'est techniquement un raccourci simpliste.
Si tu écris après :

Code :

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

1
2
3
 
MaClasse machin = truc;
machin.setBidule(3);

Cette dernière ligne ne mute pas machin : elle mute l'objet qui est référencé par machin et par truc (c'est le même et unique objet).

Donc, finalement, j'ai l'impression qu'en fait tu ne parles pas de new_contact quand tu dis que c'est modifié. Enfin, si, mais comme je le disais c'est une imprécision, un raccourci, une vue de l'esprit. Dans ta boucle, tu crées deux instances de ContactInfo qui sont stockées dans une liste qui est référencée par new_contact_array.
Chacune de ces instances a un attribut, appelé mobile. Lorsque tu instancies la première instance de ContactInfo, tu passes en paramètre la référence de liste qui se trouve dans mobile_array. L'attribut mobile de la première instance de ContactInfo contient donc la valeur qui se trouve dans mobile_array. Quand tu crées la seconde instance de ContactInfo tu passes en paramètre la même référence de liste qui se trouve dans mobile_array (tu n'as pas fait de new ArrayList<>() entre temps, c'est donc toujours la même instance de ArrayList. Cela ne modifie pas la première instance de ContactInfo : son attribut mobile contient toujours la même valeur, et c'est la même valeur qu'il y dans la seconde instance de ContactInfo, c'est-à-dire que les deux instances de ContactInfo utilise la même instance de ArrayList pour stocker les mobiles. Toute modification faite sur la liste de la seconde instance est forcément faite sur la liste de la première, puisque c'est la même liste dans les deux variables. Exactement comme dans mon exemple ExempleRecyclage : deux variables, list1 et list2 qui pointent vers une seule instance d'objet. Donc c'est une vue de l'esprit de dire que modifier la seconde instance de ContactInfo modifie la première instance. Ce n'est pas le cas : c'est simplement que les deux partagent un même objet.

J’appelle clear() au début de ma méthode, car si l’utilisateur décide de revenir sur cet onglet pour faire des modification, je dois effacer le contenu de la liste pour modifier new_contact_array au lieu de rajouter les nouvelles informations à la suite des anciennes. Mais si je crée la liste directement à l'intérieur de ma méthode, je suppose que je n'aurais plus besoin de clear() quoique se soit.

Cela peut avoir effectivement un sens pour new_contact_array, si on passe plusieurs fois dans cette méthode pour recréer toute la liste. Mais c'est surtout la liste référencée par mobile_array qu'il ne faut pas réutiliser.

Je pensais qu’il s’agissait d’une bonne pratique de programmation (je suis encore stagiaire) je pensais simplement qu’il valait mieux réutiliser les listes plutôt que d’en créer de nouvelles (par soucis de mémoire / vitesse d’exécution)

C'est une bonne pratique dans les bons cas pratiques. Cela demande bien plus de maîtrise (comprendre les interactions, les appels simultanés et/ou concurrents éventuels, ce que devient la liste (comment est-elle utilisée ensuite), la problématique de gérer un état (l'introduction du paradigme fonctionnel cherche à supprimer les états, c'est bien parce que c'est source de problèmes parfois complexes à résoudre), etc) que de créer une nouvelle liste à chaque fois.
On pourrait dans un environnement monoprocess procéder comme tu le fais, mais il faudrait dupliquer/cloner la liste dans le constructeur. Ceci peut être une bonne pratique parce que ça empêche un composant qui aurait à disposition la liste passée en paramètre d'en faire des modifications ultérieurement et donc, éventuellement, de provoquer des dysfonctionnement dans le comportement de l'objet (qui n'est pas forcément programmé pour gérer ça).

Une pratique bien meilleure est de chercher à faire fonctionner un programme d'abord, ensuite de voir où on peut optimiser en mémoire ou en temps d'exécution, si cela est nécessaire (et à part en production, c'est très rarement le cas). Si ton programme fonctionne correctement sans optimisation, laisse le tel qu'il est, ça t'évitera bien des soucis de mise au point.

Là encore, je pensais qu’il valait mieux déclarer toute les variables au même endroit, et éviter de les déclarer dans une méthode.

Dans certains vieux langages, oui, peut-être. Dans certains c'étaient même obligatoire. En Java, en tout cas, le mieux est de déclarer une variable là où on l'utilise avec la portée la plus réduite qui lui est nécessaire : non seulement ça permet plus facilement de comprendre, mais ça permet d'isoler le code (donc de le rendre facilement déplaçable=refactorisable), ça évite les soucis d'états, donc potentiellement des soucis d'accès simultanés et/ou concurrents, ça permet de plus facilement utiliser le même nom dans des contextes différents (au lieu de créer des machin1, machin2, machin3...), et ça évite d'utiliser une variable à un endroit ou un moment inapproprié, sans parler de la durée de vie de la variable, qui va influencer l'occupation mémoire et potentiellement augmenter le risque de fuite mémoire, etc.

[BreakMyMind]

Tout d’abord merci énormément pour cette réponse détaillée.

J’ai bien compris la partie sur les bonnes pratiques de programmations mais j’ai dû relire plusieurs fois la partie sur les instances / références avant d’être sûre de comprendre.
Lorsque j’ai rencontré mon problème j’avais déjà lu plusieurs questions en rapport avec le référencement dans Java mais je crois que je dois mélanger un peu mes vieux cours de C et de Java.

Quoi qu’il en soit, je pense avoir bien compris maintenant. Si je reprends mon cas, vu que je n’utilisais qu’un seul mobile_array, il était référencé dans mes deux instances de ContactInfo. Si j’effectuais une modification sur cette liste, l’attribut mobile de mes deux ContactInfo était également modifié.

Je trouve le référencement légèrement contre-intuitif car il ne paraît pas naturel qu’une variable utilisée à la ligne x pour donner une valeur à un attribut puisse modifier ce même attribut alors que seule la variable change de valeur à la ligne x+n

Une personne avertie en vaut deux, je serais beaucoup plus attentive lorsque j’attribue des valeurs à mes variables dorénavant.

Encore une fois merci pour votre réponse.

[joel.drigo]

Quoi qu’il en soit, je pense avoir bien compris maintenant. Si je reprends mon cas, vu que je n’utilisais qu’un seul mobile_array, il était référencé dans mes deux instances de ContactInfo. Si j’effectuais une modification sur cette liste, l’attribut mobile de mes deux ContactInfo était également modifié.

Ce n'est pas l'attribut mobile qui est modifié, c'est quelque chose à l'intérieur de l'objet qui est référencé par cet attribut.

Je trouve le référencement légèrement contre-intuitif car il ne paraît pas naturel qu’une variable utilisée à la ligne x pour donner une valeur à un attribut puisse modifier ce même attribut alors que seule la variable change de valeur à la ligne x+n

Cela te parait contre-intuitif parce que tu continues à confondre variable et objet. Une variable, c'est un nom circonstanciel (à un moment donné, à un endroit donné) qui permet de manipuler une référence vers un objet (ou une valeur primitif pour un type primitive, mais c'est un autre sujet). Le même objet peut être référencé par plusieurs variables. La syntaxe Java qui permet d'écrire par exemple machin.truc est un raccourci qui veut dire j'accède à l'attribut appelé truc d'un objet qui est référencé par la variable machin. machin n'est pas l'objet.

Code :

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

1
2
3
4
5
6
7
8
9
10
class Bidule {
      public int valeur;
}
Bidule a = new Bidule();
b = a;
 
a.valeur = 10;
System.out.println(b.valeur); // affiche 10
a.valeur = 42;
System.out.println(b.valeur); // affiche 42

Quand on écrit a.valeur=42, on ne modifie pas b, on modifie valeur dans l'objet de Bidule référencé par a et par b. Donc, lorsqu'on affiche b.valeur, on affiche la valeur qu'on a affecté à a.valeur, c'est le même attribut du même objet. Le seul moment où on a modifié b, c'est quand on a fait b = a. Et ll me semble plutôt intuitif que lorsqu'on modifie la propriété d'un objet, cette propriété de cet objet soit modifiée, quelque soit le nom qu'on utilise pour y accèder.

[BreakMyMind]

Je suppose que c'est une question d'habitude. J'ai personnellement encore du mal à bien saisir la subtilité du référencement.
Je pense sincèrement avoir compris mais je dois bien me concentrer pour comprendre. Cela viendra surement plus naturellement avec le temps et la pratique.

Encore merci à vous.

[joel.drigo]

J'ai personnellement encore du mal à bien saisir la subtilité du référencement.

Et bien, comme tout dans un ordinateur, un objet est un ensemble d'octets. En gros, une zone de mémoire qu'il faut pouvoir retrouver au milieu de toute la mémoire existante, et qui a une adresse donc. La JVM n'ayant pas besoin d’accéder à l'ensemble de la mémoire se contente pour simplifier d'une adresse simplifiée pour accéder à un objet, appelée référence (c'est juste un nom parce que ce n'est pas une adresse stricto sensu, comme on pourrait en utiliser en assembleur par exemple, ce n'est pas tout à fait non plus un pointeur comme en C). Pour son fonctionnement interne, la JVM a juste besoin de ça pour retrouver les données d'un objet et la syntaxe Java simplifie la gestion de cette référence : Machin a = new Machin(); consiste à mettre la référence de l'objet créé dans la variable a. Lorsqu'on décrit le processus de manière algorithmique ou fonctionnelle, on peut simplifier en confondant la variable est l'objet (genre pour System.out.println(resultat);, on va dire j'affiche le résultat, mais techniquement, il y a un certain nombre de procédé qui entrent en jeu, et, selon ce qu'on fait, il faut en tenir compte (par exemple, tenir compte du fait que cette instruction invoque la méthode toString() de l'objet pour obtenir la chaîne qui va être affichée pour représenter l'objet).

Une autre chose qui permet peut-être mieux de prendre conscience de cette notion de référence :

Code :

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

1
2
3
4
5
6
7
String s1 = new String("bonjour");
String s2 = s1;
String s3 = new String("bonjour");
System.out.println("s1.equals(s2) -> " + s1.equals(s2)); 
System.out.println("s1.equals(s3) -> " + s1.equals(s3));
System.out.println("s1==s2 -> " + s1==s2);
System.out.println("s1==s3 -> " + s1==s3);

affiche :

s1.equals(s2 -> true
s1.equals(s3) -> true
s1==s2 -> true
s1==s3 -> false

[BreakMyMind]

Machin a = new Machin(); consiste à mettre la référence de l'objet créé dans la variable a.

Ça peut paraître bête, mais je crois que c'est ce qui me manquait pour bien comprendre pourquoi a n'est qu'une référence et pas directement l'objet créé. L'exemple est lui aussi très clair. Je pense avoir bien compris, merci beaucoup

[joel.drigo]

pourquoi a n'est qu'une référence et pas directement l'objet créé.

Plus exactement, a est une VARIABLE et sa valeur est une RÉFÉRENCE. Une variable et sa valeur ne sont pas la même chose, tout comme un verre et ce qu'il contient ne sont pas la même chose, même si on a l'habitude de faire cette métonymie (boire un verre) pour nous simplifier la vie.