QCM : Mémoire et tableaux en Java (32 questions)

Questions et réponses du QCM

1. Dans un programme, que désigne le nom d’une variable ?

Un emplacement mémoire où sa valeur courante est enregistrée
Une instruction qui modifie la valeur enregistrée
La valeur courante enregistrée dans l’emplacement mémoire
L’ensemble de la mémoire réservée au programme

Un emplacement mémoire où sa valeur courante est enregistrée

Explication

Le nom d’une variable désigne l’emplacement mémoire où sa valeur courante est enregistrée. La valeur est le contenu de cet emplacement, tandis qu’une instruction ou la mémoire du programme désigne autre chose.

2. Un programme déclare une variable, lui affecte une valeur, puis termine sa durée de vie. Quelle suite décrit l’évolution de l’espace mémoire associé ?

La déclaration alloue l’espace, l’affectation crée un nouvel espace, puis la fin de vie conserve les deux
La déclaration alloue l’espace, l’affectation y stocke une valeur, puis la fin de vie le libère
La déclaration réserve l’espace, l’affectation y stocke une valeur, puis la fin de vie le garde associé au nom
La déclaration stocke une valeur, l’affectation libère l’espace, puis la fin de vie le réalloue

La déclaration alloue l’espace, l’affectation y stocke une valeur, puis la fin de vie le libère

Explication

La déclaration alloue un espace associé au nom, l’affectation y stocke une valeur et la fin de vie libère cet espace, qui pourra être réutilisé. L’inversion des rôles, la création d’un nouvel espace par l’affectation et l’absence de libération sont les erreurs visées par les autres réponses.

3. Dans un calcul, le programme lit la valeur de « total », puis affecte une nouvelle valeur à « total ». Quelle propriété caractérise la mémoire privée de cette variable ?

Elle est réservée à « total », modifiable par sa lecture et consultable par le nom d’une autre variable
Elle est réservée à « total », consultable par son nom et modifiable par une affectation à « total »
Elle est partagée entre les variables, consultable par leurs noms et modifiable par chacune d’elles
Elle est réservée à « total », consultable par son nom et modifiable par une affectation à une autre variable

Elle est réservée à « total », consultable par son nom et modifiable par une affectation à « total »

Explication

La mémoire privée est réservée à la variable : on peut consulter son contenu en utilisant son nom dans un calcul et le modifier par une affectation à cette même variable. La lecture ne modifie pas la valeur, et une affectation à une autre variable ne modifie pas cet espace privé.

4. En examinant un extrait de programme, quel élément permet d’identifier un bloc ?

Une méthode encadrée par un point-virgule et une accolade fermante
Une suite de déclarations encadrée par des parenthèses ouvrante et fermante
Une instruction conditionnelle encadrée par des crochets ouvrant et fermant
Une suite d’instructions encadrée par une accolade ouvrante et une accolade fermante

Une suite d’instructions encadrée par une accolade ouvrante et une accolade fermante

Explication

Un bloc est une suite d’instructions délimitée par une accolade ouvrante et une accolade fermante. Les parenthèses, les crochets et le point-virgule ne définissent pas cette délimitation.

5. Une variable est déclarée à l’intérieur d’un bloc dont l’exécution se termine avant celle de la méthode qui le contient. Quand cette variable cesse-t-elle d’exister ?

Au début du bloc, avant l’exécution de sa déclaration
À la fin de l’exécution du programme, quel que soit le bloc
À la fin du bloc où sa déclaration a été exécutée
À la fin de la méthode qui contient ce bloc

À la fin du bloc où sa déclaration a été exécutée

Explication

La durée de vie commence lorsque la déclaration est exécutée et se termine à la fin du bloc où la variable est déclarée. La confondre avec la durée de la méthode ou du programme prolonge à tort son existence au-delà de ce bloc.

6. Dans une boucle `while`, une déclaration située dans le corps est exécutée à chacun des quatre tours. Combien d’emplacements mémoire distincts sont créés pour cette variable au cours de la boucle ?

Cinq, un avant les tours puis un par tour
Un, créé au premier tour seulement
Un, conservé pendant les quatre tours
Quatre, un nouvel emplacement à chaque tour

Quatre, un nouvel emplacement à chaque tour

Explication

Chaque exécution de la déclaration dans le corps du `while` crée un nouvel emplacement, qui cesse d’exister à la fin du tour concerné. Un emplacement conservé pendant la boucle confond cette règle avec le comportement d’une variable déclarée dans l’initialisation d’un `for`.

7. Une boucle `for` et une boucle `while` effectuent chacune trois tours. Une variable est déclarée dans l’initialisation du `for` et une autre dans le corps du `while` : quelle comparaison décrit leur comportement ?

Les deux variables gardent le même emplacement pendant leur boucle
La variable du `for` est recréée à chaque tour ; celle du `while` garde le même emplacement
Les deux variables sont recréées à chaque tour de leur boucle
La variable du `for` garde le même emplacement ; celle du `while` est recréée à chaque tour

La variable du `for` garde le même emplacement ; celle du `while` est recréée à chaque tour

Explication

La variable déclarée dans l’initialisation du `for` reste la même à tous les tours, tandis que celle déclarée dans le corps du `while` est recréée chaque fois que sa déclaration s’exécute. Inverser ces comportements confond les deux formes de déclaration, et appliquer la recréation ou la stabilité aux deux ignore leur distinction.

8. Dans un programme, une variable `compteur` est déclarée dans l’initialisation d’un `for`, puis sa valeur doit être affichée après la boucle. Quelle modification permet cet affichage ?

Laisser `compteur` dans l’initialisation du `for` et l’utiliser après
Laisser la déclaration en place et déplacer l’affichage dans le corps du `for`
Déclarer `compteur` dans le corps du `for`, puis l’utiliser après
Déclarer `compteur` avant le `for`, puis l’utiliser dans la boucle et après

Déclarer `compteur` avant le `for`, puis l’utiliser dans la boucle et après

Explication

Une variable déclarée dans l’initialisation du `for` cesse d’exister à la fin de la boucle ; il faut la déclarer avant celle-ci pour réutiliser sa valeur ensuite. La laisser dans l’initialisation ne prolonge pas sa portée, et une déclaration dans le corps ne rend pas la variable accessible après la boucle.

9. Dans `main`, une variable locale est déclarée directement dans le bloc du corps de la méthode, puis utilisée à plusieurs endroits de ce bloc. Jusqu’à quel moment existe-t-elle ?

Jusqu’à la fin du premier tour d’une boucle éventuelle
Après la fin du bloc de `main`, tant que le programme s’exécute
Jusqu’à la fin du bloc de `main`, donc jusqu’à la fin du programme
Jusqu’à l’exécution de l’instruction suivant sa déclaration

Jusqu’à la fin du bloc de `main`, donc jusqu’à la fin du programme

Explication

Une variable déclarée dans le bloc qui constitue le corps de `main` existe jusqu’à la fermeture de ce bloc, ce qui correspond à la fin de l’exécution du programme. La durée d’un tour de boucle concerne une déclaration dans le corps d’une boucle, tandis qu’une variable locale ne persiste pas après la fin de son bloc.

10. Pour suivre un programme pas à pas, que représente une trace d’exécution ?

L’ordre des instructions exécutées, sans les états de la mémoire ni des entrées-sorties
L’état de la mémoire, des entrées clavier et des sorties écran après chaque instruction
Les seules sorties affichées à l’écran une fois le programme terminé
L’état de la mémoire et de l’écran, sans les données saisies au clavier

L’état de la mémoire, des entrées clavier et des sorties écran après chaque instruction

Explication

Une trace consigne instruction par instruction l’état de la mémoire ainsi que les entrées clavier et les sorties écran. Se limiter à l’affichage final omet les états intermédiaires, oublier le clavier néglige une partie de l’environnement, et noter le seul ordre des instructions ne décrit pas l’état du programme.

11. Dans une trace, une variable est déjà déclarée, mais l’instruction qui lui attribue une valeur n’a pas encore été exécutée. Quel symbole faut-il inscrire pour cette variable ?

0
false
?
NEP

?

Explication

Le point d’interrogation signale qu’une variable est déclarée, mais n’a pas encore reçu de valeur. NEP marque une variable qui n’existe pas encore; 0 et false sont des valeurs, et non des marqueurs d’absence d’affectation.

12. Dans une boucle for, le test de condition vient de renvoyer false après une incrémentation. Quelle est la conséquence pour l’exécution de la boucle ?

La boucle poursuit son corps une fois de plus
La boucle saute le test et exécute l’incrémentation à nouveau
La boucle recommence par son initialisation
La boucle s’arrête

La boucle s’arrête

Explication

Dans une boucle for, le test false arrête la boucle, tandis que true permet de la poursuivre. Faire continuer la boucle inverse le rôle des résultats du test; reprendre l’initialisation ou incrémenter à nouveau ne correspond pas à cette règle.

13. Lorsqu’un programme réserve de la mémoire pour une variable déclarée dans une méthode et pour un tableau, où se trouvent ces mémoires privées ?

La variable et le tableau dans le tas
La variable et le tableau dans la pile
La variable dans la pile et le tableau dans le tas
La variable dans le tas et le tableau dans la pile

La variable dans la pile et le tableau dans le tas

Explication

La pile contient les mémoires privées des variables déclarées dans les méthodes, tandis que le tas contient celles des tableaux. Inverser ces rôles confond pile et tas; placer les deux sur une même partie de la mémoire méconnaît cette division.

14. Une équipe doit désigner un emplacement contenant une variable locale et un emplacement contenant un tableau. Quels repères convient-elle d’utiliser ?

Une adresse pour la variable et un nom pour le tableau
Une adresse pour la variable et une adresse pour le tableau
Un nom pour la variable et une adresse pour le tableau
Un nom pour la variable et un nom pour le tableau

Un nom pour la variable et une adresse pour le tableau

Explication

Les emplacements de la pile, où se trouvent les variables locales, sont repérés par des noms; ceux du tas, où se trouvent les tableaux, sont repérés par des adresses. Inverser les repères transpose les règles des deux zones; employer des noms ou des adresses pour les deux ignore leur distinction.

15. Un programme exécute l’instruction new pour créer un tableau. Quel effet cette instruction produit-elle ?

Elle remplit le tableau dans le tas et en renvoie la taille
Elle alloue un espace pour le tableau dans la pile et en renvoie le nom
Elle réserve la variable dans la pile et en renvoie la valeur initiale
Elle alloue un espace adapté dans le tas et en renvoie l’adresse

Elle alloue un espace adapté dans le tas et en renvoie l’adresse

Explication

L’instruction new réserve dans le tas un espace assez grand pour le tableau, puis renvoie l’adresse de cet espace. La pile accueille les variables, et new ne remplit pas le tableau ni ne renvoie sa taille ou sa valeur initiale.

16. Après l’exécution de `boolean[] tab = new boolean[3];`, quelle valeur trouve-t-on dans chacune des trois cases du tableau ?

false dans les trois cases
true dans les trois cases
l’adresse du tableau dans chaque case
false dans la première et true dans les deux autres

false dans les trois cases

Explication

La création d’un tableau de booléens initialise ses trois cases à false. L’initialisation à true confond valeur par défaut et affectation explicite, l’adresse correspond à la variable de tableau, et la dernière réponse inverse l’état initial décrit.

17. Un programme Java exécute `System.out.println(tab)` avec `tab` de type `boolean[]`. Que représente une chaîne affichée telle que `[Z@15db9742` ?

Le contenu détaillé des cases du tableau
Une représentation de l’emplacement du tableau
La valeur booléenne de la première case
La taille du tableau en caractères

Une représentation de l’emplacement du tableau

Explication

L’affichage direct d’une variable de tableau montre une chaîne représentant son emplacement, pas ses éléments. Le contenu des cases nécessite un accès ou un affichage adapté ; la chaîne ne donne ni la taille ni la valeur de la première case.

18. Après `tab2 = tab1`, que se passe-t-il si aucune autre instruction n’est exécutée ?

Un nouveau tableau est créé et son adresse est placée dans tab2
L’adresse de tab1 est copiée dans tab2, sans changement du tas
Les valeurs du tableau existant sont remplacées par des adresses
Les cases de tab1 sont copiées dans un nouveau tableau

L’adresse de tab1 est copiée dans tab2, sans changement du tas

Explication

L’affectation recopie dans tab2 l’adresse détenue par tab1 ; elle ne modifie pas le tas et ne crée pas de tableau. Copier les cases ou en créer un nouveau confond l’affectation avec une opération de duplication, tandis que les cases ne sont pas remplacées par des adresses.

19. Dans un programme, une variable `tab2` doit recevoir l’adresse d’un tableau nouvellement créé. Quelle instruction crée effectivement ce tableau ?

`boolean[] tab2;`
`tab2[0] = false;`
`tab2 = new boolean[3];`
`tab2 = tab1;`

`tab2 = new boolean[3];`

Explication

L’instruction `new` crée le tableau ; l’affectation à tab2 y place ensuite son adresse. `tab2 = tab1` copie une adresse existante, une déclaration seule ne crée pas le tableau, et l’accès à une case ne l’alloue pas.

20. Après `tab2 = tab1`, le programme exécute `tab1[0] = true`. Quelle valeur renvoie ensuite la lecture de `tab2[0]` ?

true
l’adresse du tableau
aucune valeur, car tab2 devient invalide
false

true

Explication

Après l’affectation, tab1[0] et tab2[0] désignent la même case ; la modification par tab1 est donc visible par tab2. La réponse false suppose des tableaux distincts, l’adresse n’est pas la valeur de la case, et l’affectation ne rend pas tab2 invalide.

21. Deux variables de type tableau contiennent des adresses différentes, bien que les tableaux pointés aient les mêmes valeurs dans leurs cases. Que renvoie l’expression `t1 == t2` ?

false, car l’opérateur == teste le contenu des cases
true, car les deux variables sont de type tableau
true, car les valeurs des cases sont identiques
false, car les adresses stockées sont différentes

false, car les adresses stockées sont différentes

Explication

Pour des variables de tableau, == compare les adresses qu’elles contiennent, et des adresses différentes donnent false. L’égalité des valeurs dans les cases confond contenu et adresse, tandis que le type commun ou les noms des variables ne déterminent pas le résultat.

22. Deux variables de tableau portent des noms différents, mais désignent la même adresse dans le tas. Comment l’opérateur `==` les évalue-t-il ?

Comme égales seulement si leurs cases contiennent les mêmes valeurs
Comme égales, puisqu’elles désignent le même tableau
Comme différentes, puisque leurs noms ne sont pas identiques
Comme différentes, puisqu’elles occupent deux emplacements de variable

Comme égales, puisqu’elles désignent le même tableau

Explication

Deux variables sont égales au sens de == lorsqu’elles désignent le même tableau dans le tas, même si leurs noms diffèrent. La différence de noms ou d’emplacements de variable ne signifie pas que les adresses de tableau diffèrent; comparer les cases relève d’un autre critère.

23. Quelles sont les trois opérations qui peuvent modifier l’état de la mémoire d’un programme ?

Déclaration, comparaison et affichage d’une mémoire privée
Allocation, écriture et désallocation d’une mémoire privée
Initialisation, exécution et suppression d’une instruction
Lecture, copie et création d’une mémoire privée

Allocation, écriture et désallocation d’une mémoire privée

Explication

L’état de la mémoire change lors de l’allocation, de l’écriture et de la désallocation d’une mémoire privée. La comparaison ou l’affichage ne figurent pas dans cette liste, et la lecture n’est pas l’écriture.

24. Dans un programme, une nouvelle variable locale `compteur` est déclarée dans la pile. Quel changement de mémoire cette déclaration provoque-t-elle ?

L’écriture d’une valeur dans l’espace privé de compteur
L’allocation d’un espace privé pour compteur dans la pile
L’allocation d’un espace privé pour compteur dans le tas
La désallocation de l’espace privé de compteur

L’allocation d’un espace privé pour compteur dans la pile

Explication

L’exécution d’une déclaration de variable alloue sa mémoire privée dans la pile. L’instruction new réserve la mémoire d’un tableau dans le tas, tandis qu’une affectation réalise une écriture.

25. Après la création d’un tableau `notes`, un programme exécute `notes[1] = 12`. Quel effet cette instruction produit-elle sur la mémoire ?

Elle écrit 12 dans la mémoire privée du tableau, à la case 1
Elle écrit 12 dans la mémoire privée de la variable notes
Elle alloue un nouveau tableau dans le tas
Elle lit la valeur de la case 1 sans modifier la mémoire

Elle écrit 12 dans la mémoire privée du tableau, à la case 1

Explication

Une affectation avec des crochets à gauche écrit dans la mémoire privée du tableau, ici à l’indice 1. L’affectation à la variable notes écrirait dans la pile, une lecture ne modifierait pas la case, et l’allocation d’un tableau est l’effet de new.

26. Un tableau n’est plus accessible depuis le programme, mais celui-ci n’a pas encore besoin d’espace pour créer d’autres tableaux. Que peut-on conclure sur sa mémoire privée ?

Elle subsiste jusqu’à la fin du programme, même si la mémoire manque
Elle peut être récupérée lorsque le programme a besoin de mémoire
Elle est récupérée à la fin du bloc où le tableau a été créé
Elle est récupérée dès que le tableau devient inaccessible

Elle peut être récupérée lorsque le programme a besoin de mémoire

Explication

La mémoire d’un tableau inaccessible peut être récupérée lorsque le programme a besoin de mémoire pour en créer de nouveaux; l’inaccessibilité n’entraîne donc pas une désallocation immédiate. La fin du bloc concerne une variable de la pile, et non cette règle de récupération du tableau.

27. Dans un programme Java, une variable `texte` reçoit la chaîne « Salut ». Où se trouve la chaîne et que contient `texte` ?

La chaîne est dans le tas et `texte` contient son adresse.
La chaîne est dans la variable et le tas contient son adresse.
La chaîne est dans la pile et `texte` contient son adresse.
La chaîne est dans le tas et `texte` contient ses caractères.

La chaîne est dans le tas et `texte` contient son adresse.

Explication

Les chaînes sont stockées dans le tas, tandis qu’une variable de type `String` contient l’adresse de la mémoire privée de la chaîne. Placer la chaîne dans la pile confond les zones mémoire, stocker les caractères dans `texte` confond la référence avec son contenu, et inverser les rôles de la variable et du tas confond adresse et objet.

28. Deux variables `a` et `b` référencent deux objets `String` distincts contenant chacun « Lune ». Quel résultat produit `a == b` ?

`true`, car deux chaînes de même longueur partagent une adresse.
`true`, car les suites de caractères sont identiques.
`false`, car les adresses des mémoires privées diffèrent.
`false`, car `==` compare les caractères à rebours.

`false`, car les adresses des mémoires privées diffèrent.

Explication

En Java, `==` compare les adresses des mémoires privées des chaînes, pas leurs suites de caractères : deux objets distincts donnent donc `false`. L’égalité des contenus relève d’une autre comparaison, inverser le sens de `==` est erroné, et une longueur identique n’implique pas une adresse partagée.

29. Dans un schéma de mémoire, une référence est représentée par une flèche. Que permet d’identifier le point d’arrivée de cette flèche ?

La variable de la pile qui contient la référence.
La suite de caractères stockée dans la mémoire privée.
La mémoire privée à laquelle la référence donne accès.
La quantité de mémoire occupée par la chaîne.

La mémoire privée à laquelle la référence donne accès.

Explication

Le point d’arrivée indique la mémoire privée à laquelle la référence donne accès. La variable correspond au point de départ, le contenu est stocké dans la mémoire visée, et le dessin de la flèche ne mesure pas la quantité de mémoire.

30. Un schéma représente `msg1` et `msg3` par des flèches arrivant sur la même chaîne dans le tas, tandis que `msg2` arrive sur une autre chaîne. Quelle conclusion convient ?

Les trois variables accèdent à une même chaîne, car elles sont du type `String`.
`msg1` et `msg2` accèdent à la même chaîne, tandis que `msg3` en désigne une autre.
`msg1` et `msg3` accèdent à la même chaîne, tandis que `msg2` en désigne une autre.
`msg1` et `msg3` désignent des chaînes distinctes, car leurs flèches sont séparées.

`msg1` et `msg3` accèdent à la même chaîne, tandis que `msg2` en désigne une autre.

Explication

Deux références dont les flèches aboutissent au même objet donnent accès à la même mémoire privée; la flèche de `msg2` aboutissant ailleurs, elle désigne une autre chaîne. L’idée qu’une variable impose un objet distinct contredit le partage de référence, le type `String` ne rend pas toutes les chaînes communes, et des flèches distinctes ne signifient pas que `msg1` et `msg3` sont séparées.

31. Une étudiante veut visualiser pas à pas la mémoire d’un programme court qui demande une valeur au clavier. Quelle modification rend ce programme compatible avec Pythontutor ?

Réduire le nombre de variables sans modifier la saisie
Retirer la saisie au clavier et conserver un programme court
Remplacer l’affichage final par une saisie au clavier
Allonger le programme pour détailler chaque étape

Retirer la saisie au clavier et conserver un programme court

Explication

Pythontutor visualise l’état de la mémoire à chaque étape, mais le programme ne doit pas comporter de saisie au clavier et reste limité en nombre de lignes. Réduire les variables ne corrige pas la saisie, remplacer l’affichage par une saisie conserve le problème, et allonger le programme risque de dépasser la limite.

32. Dans l’interface de Pythontutor, un étudiant cherche la zone correspondant à la pile plutôt qu’au tas. Quel nom doit-il repérer ?

Objects
Flèches
Pythontutor
Frames

Frames

Explication

Dans Pythontutor, la pile est nommée « Frames » et le tas « Objects ». « Objects » correspond donc au tas, tandis que le nom de l’outil et les flèches ne désignent pas la pile.

Révisez avec les flashcards

Mémorisez les réponses avec 80 flashcards sur Mémoire et tableaux en Java.

Quel emplacement mémoire le nom d’une variable désigne-t-il ?

L’emplacement où sa valeur courante est enregistrée.

Que fait la déclaration d’une variable en mémoire ?

Elle alloue un espace et l’associe au nom de la variable.

Que fait une affectation à une variable ?

Elle stocke une valeur dans l’espace associé à la variable.

Voir les flashcards →

Approfondir avec la fiche

Consultez la fiche de révision complète sur Mémoire et tableaux en Java.

Voir la fiche →

Cours similaires

Crée tes propres QCM

Importe ton cours et l'IA génère des QCM avec corrections en 30 secondes.

Générateur de QCM