Cartes Java

    • Préface
      • Introduction
          • 1.1. Outil de validation
            • 1.2. Langages et notations utilisées
              • 1.3. Visualisations avec des cartes à jouer
                • 2.1. Objets
                  • 2.2. Tableaux d'objets
                    • 2.3. Graphes d'objets
                      • 3.1. Performance Vs efficacité
                        • 3.2. Efficacité en temps
                          • 3.3. Efficacité en espace
                            • 4.1. Liste naïve
                              • 4.2. Liste par tableau
                                • 4.3. Liste chaînée simple
                                  • 4.4. Liste chaînée double
                                    • 5.1. Arbre générique
                                    • 5.2. Arbre binaire
                                    • 6.1. Mappage naïf
                                      • 6.2. Mappage par hachage
                                        • 6.3. Mappage avec arbre
                                        • Conclusion
                                        • Bibliographie
                                            • Annexe 1: la notation grand O
                                              • Annexe 2: accéder aux exemples
                                                • Annexe 3: programmer un nouvel exemple
                                                  • Annexe 4: suggérer une modification à ce manuel
                                                      • Procédures déplacer/décaler
                                                        • Modéliser la suite de Fibonacci
                                                          • Liste par tableau
                                                            • Arbre binaire
                                                              • Bilan juin 2022
                                                              • Bilan octobre 2022
                                                            Tableaux d'objets
                                                            • 2.2 Tableaux d’objets
                                                              • 2.2.1 Tableau de personnages
                                                              • 2.2.2 Tableau de films
                                                              • 2.2.3 Tableau de cartes
                                                              • 2.2.4 Comprendre l’effet d’instructions typiques
                                                                • 2.2.4.1 Accéder à une valeur
                                                                • 2.2.4.2 Déplacer un objet (déplacer une carte)
                                                                • 2.2.4.3 Copier la référence à un objet
                                                                • 2.2.4.4 Créer un nouvel objet (créer une nouvelle carte)
                                                              • 2.2.5 Références multiples

                                                            Section 2.2: tableaux d’objets #

                                                            Une fois les objets modélisés, la prochaine étape est de spécifier les relations entre ces objets, c.-à-d. l’organisation de ces objets dans la mémoire du programme.

                                                            2.2.1 Tableau de personnages #

                                                            On peut améliorer la modélisation d’un film présentée au chapitre précédent en ajoutant la relation suivante :

                                                            • Un film contient des personnages :

                                                            Voici des exemples de données se conformant à cette modélisation :

                                                            {
                                                              "_C": "Film",
                                                              "titre": "Dr. No",
                                                              "annee": 1962,
                                                              "personnages": [
                                                                {
                                                                  "_C": "PersonnageObjet",
                                                                  "nom": "James Bond",
                                                                  "personnagePrincipal": true
                                                                },
                                                                {
                                                                  "_C": "PersonnageObjet",
                                                                  "nom": "Docteur No",
                                                                  "personnagePrincipal": false
                                                                }
                                                              ]
                                                            
                                                            {
                                                              "_C": "Film",
                                                              "titre": "Bons Baisers de Russie",
                                                              "annee": 1963,
                                                              "personnages": [
                                                                {
                                                                  "_C": "PersonnageObjet",
                                                                  "nom": "James Bond",
                                                                  "personnagePrincipal": true
                                                                },
                                                                {
                                                                  "_C": "PersonnageObjet",
                                                                  "nom": "Rosa Klebb",
                                                                  "personnagePrincipal": false
                                                                }
                                                              ]
                                                            

                                                            2.2.2 Tableau de films #

                                                            On peut améliorer la modélisation d’un personnage présentée au chapitre précédent en ajoutant la relation suivante :

                                                            • Un personnage apparaît dans un ou plusieurs films :

                                                            Voici des exemples de données se conformant à cette modélisation :

                                                            {
                                                              "_C": "Personnage",
                                                              "nom": "James Bond",
                                                              "personnagePrincipal": true,
                                                              "films": [
                                                                {
                                                                  "_C": "FilmObjet",
                                                                  "titre": "Dr. No",
                                                                  "annee": 1962
                                                                },
                                                                {
                                                                  "_C": "FilmObjet",
                                                                  "titre": "Bons Baisers de Russie",
                                                                  "annee": 1963
                                                                }
                                                              ]
                                                            
                                                            {
                                                              "_C": "Personnage",
                                                              "nom": "Docteur No",
                                                              "personnagePrincipal": false,
                                                              "films": [
                                                                {
                                                                  "_C": "FilmObjet",
                                                                  "titre": "Dr. No",
                                                                  "annee": 1962
                                                                }
                                                              ]
                                                            

                                                            2.2.3 Tableau de cartes #

                                                            Les exemples de tableau de cartes sont plus pertinents à notre approche. Considérer le diagramme de classe suivant :

                                                            Voici des exemples de tableau de cartes :

                                                            2.2.4 Comprendre l’effet d’instructions typiques #

                                                            Pour comprendre comment les cartes sont animées dans l’outil de validation, il est important de comprendre l’effet d’instructions typiques.

                                                            2.2.4.1 Accéder à une valeur #

                                                            Objets au départInstructionsRésultat
                                                            memoireA.getNumero();
                                                            memoireA.getSorte();
                                                            
                                                            5
                                                            "TREFLE"
                                                            
                                                            Objets au départInstructionsRésultat
                                                            cartes[2].getNumero();
                                                            cartes[2].getSorte();
                                                            
                                                            3
                                                            "CARREAU"
                                                            
                                                            Objets au départInstructionsRésultat
                                                            cartes[2].getNumero();
                                                            memoireB.getNumero();
                                                            
                                                            java.lang.NullPointerException
                                                            java.lang.NullPointerException
                                                            

                                                            2.2.4.2 Déplacer un objet (déplacer une carte) #

                                                            Objets au départInstructionRésultat
                                                            memoireA = cartes[0];
                                                            cartes[0] = null;
                                                            
                                                            Objets au départInstructionRésultat
                                                            cartes[2] = cartes[0];
                                                            cartes[0] = null;
                                                            

                                                            2.2.4.3 Copier la référence à un objet #

                                                            Objets au départInstructionRésultat
                                                            memoireA = cartes[0];
                                                            
                                                            Objets au départInstructionRésultat
                                                            cartes[2] = cartes[0];
                                                            

                                                            2.2.4.4 Créer un nouvel objet (créer une nouvelle carte) #

                                                            Objets au départInstructionRésultat
                                                            memoireA = new Carte(2, "TREFLE");
                                                            
                                                            Objets au départInstructionRésultat
                                                            memoireB = new Carte(5, "TREFLE");
                                                            

                                                            2.2.5 Références multiples #

                                                            Typiquement, on va copier une référence à un objet, plutôt que déplacer l’objet.

                                                            TypiquePlus rare
                                                            memoireA = cartes[0];
                                                            
                                                            memoireA = cartes[0];
                                                            cartes[0] = null;
                                                            

                                                            Le résultat est qu’on a des références multiples: plusieurs références vers le même objet.

                                                            Si on visualise du code typique avec les cartes, on va visualiser les références multiples en affichant plusieurs copies d’une carte.

                                                            La visualisation est correcte, mais plus difficile à lire.

                                                            Autant que possible, on va expliquer les procédures en déplaçant les cartes, c.-à-d. en évitant de créer des références multiples. Cependant, il faut garder en tête que le code typique contient très souvent des références multiples.



                                                            ↪ Section 2.3:  graphes d'objets
                                                            FabriqueREL
                                                            Creative Commons License
                                                            Modifier cette page Edit
                                                            Collège Montmorency
                                                            • 2.2 Tableaux d’objets
                                                              • 2.2.1 Tableau de personnages
                                                              • 2.2.2 Tableau de films
                                                              • 2.2.3 Tableau de cartes
                                                              • 2.2.4 Comprendre l’effet d’instructions typiques
                                                                • 2.2.4.1 Accéder à une valeur
                                                                • 2.2.4.2 Déplacer un objet (déplacer une carte)
                                                                • 2.2.4.3 Copier la référence à un objet
                                                                • 2.2.4.4 Créer un nouvel objet (créer une nouvelle carte)
                                                              • 2.2.5 Références multiples