QCM : Variables et structures en Java (53 questions)

Questions et réponses du QCM

1. Une équipe doit choisir entre Java et Python pour un logiciel embarqué où la vitesse d’exécution et la détection précoce d’erreurs de type sont prioritaires. Quel choix correspond aux caractéristiques présentées pour Java ?

Python, grâce à sa syntaxe simple et lisible
Java, grâce au bytecode et au typage statique
Python, grâce au bytecode et au typage statique
Java, grâce à son typage dynamique et au prototypage

Java, grâce au bytecode et au typage statique

Explication

Java est présenté comme plus rapide à l’exécution grâce à la compilation en bytecode et son typage statique aide à détecter les erreurs à la compilation. Le prototypage rapide renvoie plutôt à Python, et le typage dynamique ne décrit pas Java ici.

2. Parmi les ensembles suivants, lequel réunit des notions explicitement abordées dans le module d’algorithmique ?

Applications mobiles et serveurs, avec jeux, réseaux et bases de données
Programmation impérative et objet, avec chaînes, booléens et flottants
Tri et recherche, avec tableaux, piles et nombres entiers
Tri et graphes, avec arbres, tables de hachage et listes chaînées

Tri et graphes, avec arbres, tables de hachage et listes chaînées

Explication

Le module aborde les algorithmes de tri et de graphe, ainsi que les arbres, les tables de hachage et les listes chaînées. La recherche, les piles et les tableaux ne remplacent pas les notions énumérées dans cette unité.

3. Dans un fichier Java nommé `Calculatrice.java`, un étudiant écrit `class Calculatrice { ... }`. Quel rôle joue ici le mot-clé `class` ?

Il délimite le bloc du programme sans introduire son nom
Il introduit la méthode principale, dont le code suit entre accolades
Il introduit le nom du programme, dont le code suit entre accolades
Il lance l’exécution du programme à partir de la méthode principale

Il introduit le nom du programme, dont le code suit entre accolades

Explication

Dans l’exemple, `class` sert à définir le nom du programme et le code associé se trouve entre les accolades qui suivent. Le démarrage de l’exécution est associé à la ligne `main`, tandis que les accolades délimitent le bloc.

4. Un fichier s’appelle `Rapport.java`, mais la déclaration commence par `class rapport { ... }`. Quelle correction respecte la règle de nommage présentée ?

Écrire `class rapport`, car la casse ne modifie pas la correspondance
Écrire `class Rapport.java`, en incluant l’extension dans le nom
Écrire `class Rapport`, en conservant la même casse que le fichier
Écrire `class main`, en reprenant le nom du point d’entrée

Écrire `class Rapport`, en conservant la même casse que le fichier

Explication

Le nom du programme doit correspondre au nom du fichier, casse comprise : `Rapport` doit donc être écrit avec la même majuscule. La casse est significative, et l’extension `.java` ne fait pas partie du nom de classe attendu.

5. Dans un programme Java, une instruction d’affichage précède la méthode `main`, tandis que plusieurs instructions se trouvent entre les accolades qui la suivent. À partir de quel endroit l’exécution commence-t-elle ?

À la ligne `public static void main(String[] args)`, puis dans son bloc
À la ligne `class`, puis dans le bloc de la classe
À la première instruction d’affichage, avant la méthode `main`
À la dernière accolade du programme, puis dans le bloc de la classe

À la ligne `public static void main(String[] args)`, puis dans son bloc

Explication

L’exécution commence à la ligne `public static void main(String[] args)` et se poursuit dans le code entre les accolades qui suivent. La déclaration de classe organise le programme, mais ne remplace pas ce point d’entrée.

6. Une équipe veut nommer une variable Java avec `score2`, `_score` ou `2score`. Laquelle de ces propositions respecte les règles de formation des symboles ?

`2score`
`score-score`
`score2`
`score score`

`score2`

Explication

Un symbole peut contenir des lettres, des chiffres après le premier caractère, `_` ou `$` ; `score2` respecte donc la règle. `2score` commence par un chiffre, tandis que le trait d’union et l’espace ne font pas partie des caractères cités.

7. Dans le programme `int age = 42;`, quelle catégorie décrit la valeur `42` ?

Un symbole
Une valeur littérale
Un mot-clé
Un type

Une valeur littérale

Explication

`42` est une valeur écrite directement dans le programme et constitue donc une valeur littérale. `int` est un type, `age` un symbole, et les mots-clés sont des éléments réservés du langage.

8. Un développeur traduit en Java un bloc Python dont les niveaux sont indiqués par l’indentation. Quel élément doit-il utiliser pour structurer le bloc Java ?

Des accolades
L’indentation seule
Des points-virgules
Des parenthèses

Des accolades

Explication

Java délimite la structure des blocs par des accolades, alors que Python s’appuie sur l’indentation. Utiliser l’indentation seule transpose donc la règle de Python ; les parenthèses et les points-virgules ne délimitent pas ces blocs.

9. Deux versions d’un même programme Java ont les mêmes instructions et accolades, mais l’une utilise davantage d’espaces et une indentation différente. Quel effet cette modification a-t-elle sur le comportement du programme ?

Elle change l’exécution dès que les instructions sont espacées différemment.
Elle améliore ou réduit la lisibilité sans changer ce que fait le programme.
Elle modifie la portée des blocs en fonction des espaces utilisés.
Elle modifie le comportement parce que l’indentation structure le code Java.

Elle améliore ou réduit la lisibilité sans changer ce que fait le programme.

Explication

En Java, les espaces et l’indentation servent à la lisibilité ; si la structure reste identique, l’espacement ne change pas ce que fait le programme. L’idée que l’indentation structure le code transpose à Java la règle de Python, et les espaces ne modifient pas la portée des blocs.

10. Une classe Java contient `public static void Main(String[] args)` avec une majuscule à `Main`. Quel est le résultat au lancement du programme ?

La méthode est reconnue, car `static` peut être omis dans la signature.
La méthode d’entrée n’est pas reconnue, car sa signature doit être exacte.
La méthode est reconnue, car seule la liste des arguments compte.
La méthode est reconnue, car `void` peut être remplacé par `String`.

La méthode d’entrée n’est pas reconnue, car sa signature doit être exacte.

Explication

Java exige la signature exacte `public static void main(String[] args)`, y compris la casse de `main`. Ignorer la casse fait manquer le nom requis, omettre `static` modifie aussi la signature et remplacer `void` par `String` ne respecte pas davantage la forme attendue.

11. Un fichier Python définit une fonction puis contient un appel à `print` au niveau du fichier. Que se passe-t-il lorsque ce fichier est importé par un autre programme ?

L’appel à `print` s’exécute seulement si une fonction est appelée.
L’appel à `print` est exécuté lors de l’importation.
L’appel à `print` attend le lancement direct du fichier.
L’appel à `print` est ignoré tant qu’aucun module ne l’utilise.

L’appel à `print` est exécuté lors de l’importation.

Explication

En Python, les instructions exécutables rencontrées dans un fichier sont exécutées aussi lors de son importation. Penser que l’importation ne charge que les définitions ou la confondre avec le lancement direct conduit à croire, à tort, que l’appel est différé.

12. Un module Python contient des fonctions et place un bloc d’instructions sous `if __name__ == "__main__":`. Que se passe-t-il pour ce bloc lorsque le module est importé ?

Le bloc est exécuté avant que les fonctions du module soient importées.
Le bloc est exécuté, car tout code Python s’exécute pendant l’importation.
Les fonctions du module ne peuvent pas être importées tant que le bloc est présent.
Le bloc n’est pas exécuté, mais les fonctions du module peuvent être importées.

Le bloc n’est pas exécuté, mais les fonctions du module peuvent être importées.

Explication

Le test `if __name__ == "__main__":` réserve le bloc placé dessous au lancement direct du fichier, sans empêcher l’importation de ses fonctions. Confondre importation et lancement direct inverse le comportement du test; penser qu’il bloque les fonctions étend à tort sa portée.

13. Dans un programme Java, une première instruction affiche `Salut` avec `System.out.print`, puis une seconde affiche `!` avec `System.out.println`. Quel affichage obtient-on ?

`Salut!` sur une ligne, puis un retour à la ligne.
`!Salut` sur une ligne, puis un retour à la ligne.
`Salut` sur une ligne, puis un retour à la ligne avant `!`.
`Salut` puis `!` sur deux lignes distinctes.

`Salut!` sur une ligne, puis un retour à la ligne.

Explication

`print` affiche son paramètre sans ajouter de nouvelle ligne, puis `println` affiche `!` et ajoute le retour à la ligne. Attribuer le retour à `print` sépare à tort les affichages; croire que `println` n’affiche que le retour omet son paramètre, et inverser l’ordre ne respecte pas l’ordre des instructions.

14. Une instruction Java se termine par `;`, puis le bloc d’une méthode se termine par `}`. Quelle ponctuation doit suivre l’accolade fermante ?

Une virgule après l’accolade.
Un point-virgule après l’accolade.
Un deux-points après l’accolade.
Aucune ponctuation supplémentaire.

Aucune ponctuation supplémentaire.

Explication

En Java, les instructions se terminent par un point-virgule, mais une accolade fermante n’est pas suivie de ce signe. Le point-virgule après l’accolade applique à tort la règle des instructions au bloc; la virgule et les deux-points ne terminent pas non plus ce bloc.

15. Une personne écrit une instruction directement dans une classe Java, entre l’accolade ouvrante de la classe et la déclaration de `main`. Quelle modification respecte la structure attendue ?

Placer l’instruction dans une méthode déclarée dans la classe.
Placer l’instruction dans une seconde déclaration de classe imbriquée.
Déplacer l’instruction après l’accolade fermante de la classe.
Laisser l’instruction dans la classe et ajouter un point-virgule.

Placer l’instruction dans une méthode déclarée dans la classe.

Explication

Le code Java doit se trouver dans des fonctions déclarées dans une classe; une instruction ne peut pas être placée directement sous la déclaration de classe. Ajouter un point-virgule ne corrige pas son emplacement, et la déplacer hors de la classe ou dans une classe imbriquée ne satisfait pas la structure attendue.

16. Une équipe compile un programme Java puis veut le lancer. Quelle suite décrit correctement le passage du code source à son exécution ?

Traduire le source en bytecode, puis faire interpréter ce bytecode par la JVM
Faire exécuter directement le fichier source par la JVM, sans traduction
Faire interpréter le source par la JVM, puis traduire le résultat en bytecode
Faire exécuter le bytecode par le compilateur, puis l’interpréter avec la JVM

Traduire le source en bytecode, puis faire interpréter ce bytecode par la JVM

Explication

La compilation transforme le source Java en bytecode, que la JVM interprète ensuite. Interpréter le source avant sa traduction inverse les étapes, tandis que le compilateur ne se charge pas de l’exécution.

17. Pour compiler puis lancer le programme contenu dans `Hello.java`, quels outils et fichiers faut-il associer ?

`javac` produit `Hello.java`, puis `java` exécute le source
`java` produit `Hello.class`, puis `javac` exécute le bytecode
`javac` produit `Hello.class`, puis `java` exécute le bytecode
`java` produit `Hello.java`, puis `javac` exécute le source

`javac` produit `Hello.class`, puis `java` exécute le bytecode

Explication

`javac` compile le fichier source `.java` en bytecode `.class`, puis `java` exécute ce bytecode. Échanger les outils ou inverser les extensions confond les étapes de compilation et d’exécution.

18. Une équipe souhaite lancer le même fichier bytecode Java sur des ordinateurs utilisant des systèmes différents. Quelle propriété rend cela possible ?

Le compilateur produit un fichier `.class` particulier pour chaque plateforme
Le fichier source `.java` est exécuté par une JVM identique sur toute plateforme
La JVM permet d’exécuter le même fichier `.class` sur différentes plateformes
Le processeur exécute directement le même fichier `.class` sur toute plateforme

La JVM permet d’exécuter le même fichier `.class` sur différentes plateformes

Explication

Le bytecode peut être exécuté sur différentes plateformes par leur JVM, ce qui rend le même fichier `.class` portable. Un fichier par système contredit cette portabilité, et le processeur ne lance pas directement le bytecode.

19. En Java, quelle description caractérise une variable ?

Un symbole qui possède un nom, une valeur et une extension de fichier
Un emplacement mémoire qui possède un type, une portée et une taille fixe
Une valeur littérale qui possède un nom, un type et une adresse mémoire
Un emplacement mémoire qui possède un nom, un type et une valeur

Un emplacement mémoire qui possède un nom, un type et une valeur

Explication

Une variable est un emplacement mémoire associé à un nom, un type et une valeur. La valeur littérale seule n’est pas la variable, et la définition ne remplace pas ces trois éléments par une extension ou une portée.

20. Un programme doit stocker un entier signé dans un type primitif de 2 octets. Quel type convient ?

`long`
`int`
`byte`
`short`

`short`

Explication

Parmi les types primitifs entiers signés, `short` occupe 2 octets. `byte` en occupe 1, `int` 4 et `long` 8.

21. Une développeuse veut représenter le texte « Salut » dans une variable Java. Quelle affirmation décrit correctement le type à choisir ?

`char` représente la chaîne, et constitue un type primitif
`float` représente la chaîne, mais n’est pas un type primitif
`int` représente la chaîne, et constitue un type primitif
`String` représente la chaîne, mais n’est pas un type primitif

`String` représente la chaîne, mais n’est pas un type primitif

Explication

`String` sert à représenter une chaîne de plusieurs caractères, mais ne fait pas partie des types primitifs. `char` est le type primitif associé à un caractère Unicode, pas à une chaîne complète.

22. Dans une déclaration Java, une valeur entière est écrite avec le suffixe minuscule `l`. Quel est son type ?

`long`
`double`
`int`
`float`

`long`

Explication

Un littéral entier suivi de `l` est de type `long`, alors qu’un entier sans suffixe est de type `int`. Les types `float` et `double` concernent les littéraux réels, pas ce suffixe entier.

23. Une variable Python contient d’abord l’entier `1`, puis reçoit la chaîne `"Bonjour"`. Quelle différence avec une variable Java de type `int` illustre cette situation ?

En Python, la valeur doit garder le même type, tandis qu’en Java elle peut changer de type.
Dans les deux langages, son type peut changer à l’exécution.
En Python, son type peut changer à l’exécution, tandis qu’en Java son type reste fixe.
En Java, son type peut changer, tandis qu’en Python il reste fixe.

En Python, son type peut changer à l’exécution, tandis qu’en Java son type reste fixe.

Explication

Le typage de Python est dynamique : le type d’une variable peut changer à l’exécution, tandis qu’en Java le type déclaré reste fixe. La conversion automatique et le changement de type en Java confondent les comportements des deux langages.

24. En Python, que représentent `'abc'` et `"abc"`, et que se passe-t-il en Java avec ces mêmes délimiteurs ?

Ils représentent deux types de chaîne distincts en Python ; en Java, les deux formes sont des chaînes.
Ils représentent la même chaîne en Python ; en Java, les apostrophes délimitent un caractère et les guillemets une chaîne.
Ils représentent un caractère en Python avec les apostrophes ; en Java, les deux formes sont des caractères.
Ils représentent la même chaîne dans les deux langages, quelle que soit la délimitation.

Ils représentent la même chaîne en Python ; en Java, les apostrophes délimitent un caractère et les guillemets une chaîne.

Explication

Python traite `'abc'` et `"abc"` comme la même chaîne, alors qu’en Java les apostrophes délimitent un caractère et les guillemets une chaîne. Distinguer ces formes en Python transpose la règle de Java, tandis que traiter les deux formes Java comme des chaînes ou des caractères méconnaît leur distinction.

25. Dans un programme Java, une variable entière `compteur` vaut `7`. Quelle opération la fait passer à `8` à l’aide d’un opérateur d’incrémentation ?

`compteur += 0`
`compteur % 1`
`compteur--`
`compteur++`

`compteur++`

Explication

L’opérateur `++` incrémente la variable, donc sa valeur passe de 7 à 8. `--` décrémente, `+= 0` ne change pas la valeur et `%` calcule un reste.

26. Une condition Java doit être vraie si `actif` est vrai et `autorise` est faux. Quelle expression emploie les opérateurs booléens Java appropriés ?

`actif && autorise`
`actif && !autorise`
`actif || !autorise`
`actif and not autorise`

`actif && !autorise`

Explication

En Java, `&&` signifie « et » et `!` signifie « non » : l’expression demande donc que `actif` soit vrai et que `autorise` soit faux. `and` et `not` sont les mots-clés de Python, `||` exprime « ou », et l’absence de négation exige que `autorise` soit vrai.

27. Un programme Java calcule `9 / 4` avec deux opérandes entiers, puis `9.0 / 4`. Quels résultats obtient-il, dans cet ordre ?

`2.25` puis `2`
`2.25` puis `2.25`
`2` puis `2`
`2` puis `2.25`

`2` puis `2.25`

Explication

En Java, la division de deux entiers donne un résultat entier : `9 / 4` vaut 2. Avec un opérande réel, le résultat est réel et vaut `9.0 / 4 = 2.25`; Java n’utilise pas `//` comme opérateur de division entière.

28. En Java, quels éléments délimitent un bloc d’instructions ?

Un point-virgule au début et un à la fin
Une parenthèse ouvrante et une parenthèse fermante
Une accolade ouvrante et une accolade fermante
Un crochet ouvrant et un crochet fermant

Une accolade ouvrante et une accolade fermante

Explication

Un bloc Java est une suite d’instructions encadrée par une accolade ouvrante et une accolade fermante. Les parenthèses encadrent notamment des conditions, le point-virgule termine une instruction et les crochets servent notamment aux tableaux.

29. Dans une chaîne `if`/`else if`/`else`, la première condition est fausse, la deuxième est vraie et une troisième condition aurait aussi été vraie : quel corps est exécuté ?

Les corps associés aux deuxième et troisième conditions
Le corps associé à la branche else
Le corps associé à la deuxième condition
Le corps associé à la troisième condition

Le corps associé à la deuxième condition

Explication

La chaîne exécute le corps associé à la première condition vérifiée, puis ne poursuit pas l’évaluation des branches suivantes. Exécuter plusieurs corps confond cette structure avec des tests indépendants, et choisir `else` ou la dernière condition néglige l’ordre des branches.

30. Dans un `switch` classique, une valeur ne correspond à aucune étiquette `case` : quel bloc est exécuté si le `switch` comporte une branche `default` ?

Le bloc du premier `case`
La valeur du `switch` est affectée à une variable
Le bloc `default`
Aucun bloc du `switch`

Le bloc `default`

Explication

Dans un `switch` classique, `default` s’exécute lorsqu’aucune étiquette `case` ne correspond. Le premier `case` n’est pas un choix de repli, et l’affectation d’une valeur caractérise l’usage du `switch` comme expression.

31. Dans un `switch` expression Java, un cas utilise un bloc de plusieurs instructions et doit fournir une valeur pour l’expression : quel mot-clé indique cette valeur ?

`return`
`->`
`default`
`yield`

`yield`

Explication

Dans un bloc d’un `switch` expression, `yield` indique la valeur retournée par ce bloc. `return` concerne le retour d’une méthode, `->` introduit la forme du cas et `default` désigne la branche de repli.

32. Un programme entre dans une boucle alors que sa condition est déjà fausse. Quelle comparaison entre `do…while` et `while` est correcte ?

`do…while` exécute son corps une fois, tandis que `while` peut ne pas l’exécuter
`while` exécute son corps une fois, tandis que `do…while` peut l’omettre
Les deux exécutent leur corps une fois avant de tester la condition
`do…while` et `while` omettent tous deux le corps si la condition est fausse

`do…while` exécute son corps une fois, tandis que `while` peut ne pas l’exécuter

Explication

`do…while` teste sa condition après l’exécution du corps, qui s’exécute donc au moins une fois; `while` teste d’abord la condition et peut sauter le corps. Garantir une exécution à `while` inverse la distinction, et les deux autres réponses attribuent aux boucles le même ordre de test.

33. Une boucle Java doit initialiser `i` à 0, continuer tant que `i` est inférieur à 4 et augmenter `i` après chaque passage : où ces trois éléments sont-ils regroupés ?

Dans le corps du `for`, après chaque instruction exécutée
Dans une collection parcourue implicitement par le `for`
Dans l’en-tête du `for`, avec initialisation, condition et itération
Dans l’en-tête du `while`, sans emplacement pour l’initialisation

Dans l’en-tête du `for`, avec initialisation, condition et itération

Explication

Le `for` Java regroupe l’initialisation, la condition et l’itération dans son en-tête, puis exécute son corps tant que la condition est vraie. Mettre l’initialisation dans le corps ou utiliser un parcours implicite de collection confond sa structure avec d’autres formes de boucle.

34. Une étudiante veut parcourir directement les éléments d’une liste en Python, puis écrire une boucle Java en précisant une initialisation, une condition et une itération : quelle comparaison correspond à ces usages ?

Le `for` Python parcourt par défaut une collection; le `for` Java permet de préciser les trois éléments
Le `for` Python permet de préciser les trois éléments; le `for` Java parcourt par défaut une collection
Les deux formes de `for` regroupent l’initialisation, la condition et l’itération
Les deux formes de `for` exigent une collection à parcourir

Le `for` Python parcourt par défaut une collection; le `for` Java permet de préciser les trois éléments

Explication

Le `for` Python parcourt par défaut une collection, tandis que le `for` Java permet de préciser l’initialisation, la condition et l’itération dans son en-tête. Les autres propositions attribuent à tort à Python la forme du Java, ou généralisent l’une de ces structures aux deux langages.

35. Quelle propriété définit un tableau en Java ?

Il contient plusieurs éléments de types différents.
Il associe chaque élément à un type différent.
Il contient une seule valeur, éventuellement composée.
Il contient plusieurs éléments du même type.

Il contient plusieurs éléments du même type.

Explication

Un tableau Java regroupe plusieurs éléments de même type. L’option sur les types différents confond le tableau avec une collection hétérogène; celle sur la valeur unique le confond avec une variable simple; celle sur les indices attribue à tort un type différent à chaque élément.

36. Pour créer un tableau de 8 valeurs de type `double` et obtenir une référence vers celui-ci, quelle expression faut-il utiliser ?

double[] tab;
new double[]
new double[8]
new double[][8]

new double[8]

Explication

L’expression `new type[n]` alloue un tableau de `n` éléments et renvoie une référence vers ce tableau. `double[] tab;` déclare une variable de référence sans allouer le tableau, tandis que les autres expressions omettent la taille ou placent incorrectement les crochets.

37. Un tableau `tab` contient 5 éléments. Quelle expression donne son dernier indice valide ?

tab.length - 2
tab.length - 1
tab.length
tab.length + 1

tab.length - 1

Explication

Les indices d’un tableau vont de 0 à `tab.length - 1`; pour cinq éléments, le dernier indice est donc 4. `tab.length` désigne le nombre d’éléments et non un indice valide, tandis que les autres valeurs décalent la borne ou supposent un départ à 1.

38. Dans un programme Java, quelle taille la machine virtuelle attribue-t-elle aux types `byte`, `char`, `int` et `long`, dans cet ordre ?

1, 2, 2 et 8 octets
1, 2, 4 et 8 octets
1, 2, 8 et 4 octets
2, 1, 4 et 8 octets

1, 2, 4 et 8 octets

Explication

La machine virtuelle Java fixe ces tailles à 1 octet pour `byte`, 2 pour `char`, 4 pour `int` et 8 pour `long`. La série commençant par 2 inverse `byte` et `char`; celle donnant 2 à `int` lui attribue la taille de `short`; la dernière intervertit `int` et `long`.

39. Quel contraste décrit correctement les types primitifs et les types par référence en Java ?

Les primitifs représentent une valeur de taille fixe; les références désignent des données pouvant varier en taille.
Les primitifs désignent des données de taille variable; les références représentent une valeur de taille fixe.
Les primitifs et les références représentent tous deux directement une valeur de taille fixe.
Les primitifs et les références désignent tous deux des données de taille variable.

Les primitifs représentent une valeur de taille fixe; les références désignent des données pouvant varier en taille.

Explication

Un type primitif représente directement une valeur et possède une taille fixe, tandis qu’un type par référence désigne des données dont la taille peut varier, par leur adresse de début. L’inversion des deux catégories confond leurs propriétés; les deux autres réponses effacent cette distinction en leur attribuant des caractéristiques identiques.

40. En Java, `copie` reçoit la référence de `original`, qui désigne un tableau. Si `copie[0]` est modifié, que constate-t-on en lisant `original[0]` ?

L’ancienne valeur, car l’affectation a copié le tableau.
La nouvelle valeur, car les deux variables désignent le même tableau.
L’ancienne valeur, car chaque variable possède son propre tableau.
Une valeur indéterminée, car les références se désynchronisent.

La nouvelle valeur, car les deux variables désignent le même tableau.

Explication

Quand deux variables référencent le même tableau, une modification effectuée par l’une est visible par l’autre : c’est l’aliasing. La copie du tableau confond affectation de référence et duplication des données; les autres réponses supposent à tort que les variables désignent des tableaux distincts ou que les références se désynchronisent.

41. Une variable Java de type `int` reçoit la valeur `12`. Qu’est-ce que cette variable contient directement ?

Une référence vers une chaîne contenant « 12 ».
La valeur entière 12.
Une référence vers un objet contenant 12.
Une adresse vers un tableau d’entiers.

La valeur entière 12.

Explication

Une variable de type primitif contient directement sa valeur; `int` fait partie des types primitifs Java. Une référence vers un objet, une chaîne ou un tableau correspond à un type référence, et non au contenu d’une variable `int`.

42. Dans un programme Java lancé avec `java Outil alpha beta`, à quoi correspond le tableau référencé par `args` dans `main` ?

Aux paramètres d’entrée déclarés par les autres méthodes
Aux caractères composant le nom du programme
Aux chaînes représentant les arguments transmis au programme
Aux résultats renvoyés par les méthodes du programme

Aux chaînes représentant les arguments transmis au programme

Explication

`args` référence un tableau de chaînes contenant les arguments transmis au programme. Les paramètres d’autres méthodes, les valeurs de retour et les caractères du nom du programme sont des notions différentes.

43. Un programme Java est lancé avec `java Outil alpha beta gamma`. Quelle chaîne se trouve dans `args[1]` ?

`beta`
`gamma`
`3`
`alpha`

`beta`

Explication

L’indice zéro désigne le premier argument et l’indice un le second : `args[1]` contient donc `beta`. `alpha` correspond au premier argument, `gamma` au troisième, et `3` est le nombre total d’arguments.

44. Quelle description caractérise une méthode en programmation ?

Un point d’entrée du programme pouvant recevoir des arguments et lancer son exécution
Un type de donnée réutilisable pouvant contenir des instructions et renvoyer un résultat
Une variable qui conserve une valeur réutilisable et peut recevoir des arguments
Un regroupement d’instructions réutilisable pouvant recevoir des arguments et renvoyer un résultat

Un regroupement d’instructions réutilisable pouvant recevoir des arguments et renvoyer un résultat

Explication

Une méthode regroupe des instructions en une macro-instruction réutilisable, qui peut recevoir des arguments et renvoyer un résultat. Une variable conserve une valeur, un type définit une catégorie de données et `main` est le point d’entrée du programme.

45. Une étudiante déclare une méthode de classe Java nommée `calculer`, qui reçoit un entier `n`, renvoie un entier et possède un corps. Quelle structure respecte les éléments attendus d’une telle déclaration ?

`static calculer(int n) int { ... }`
`static int calculer(int n) { ... }`
`static int calculer(int n) ...`
`static int calculer(n) { ... }`

`static int calculer(int n) { ... }`

Explication

Une méthode de classe comporte un nom, des paramètres déclarés avec leur type et leur nom, un type de résultat, et un corps entre accolades. `n` sans type omet une information, le type de résultat est mal placé dans `calculer(n) int`, et la dernière structure ne délimite pas le corps.

46. Dans une classe Java, les méthodes `f(int x)` et `f(double x)` sont toutes deux déclarées. Lorsqu’un appel transmet un argument de type `int`, quel principe détermine la méthode appelée ?

Le nom partagé rend ces deux déclarations incompatibles
Le type de l’argument sélectionne la méthode `f(int x)`
Le type de résultat sélectionne la méthode `f(double x)`
L’ordre de déclaration sélectionne la méthode écrite en premier

Le type de l’argument sélectionne la méthode `f(int x)`

Explication

La surcharge permet à des méthodes de même nom d’avoir des types de paramètres différents, et Java choisit selon le type de l’argument ; ici, l’entier correspond à `f(int x)`. Le type de résultat et l’ordre de déclaration ne sont pas les critères décrits, et le nom partagé n’interdit pas la surcharge.

47. Une méthode Java de type `void` exécute ses instructions jusqu’à la fin de son corps sans écrire d’instruction `return`. Que se passe-t-il à la fin ?

La méthode continue de s’exécuter après son corps
Un entier implicite est renvoyé par la méthode
Un `return` implicite termine la méthode
Un `return` explicite est exigé pour terminer la méthode

Un `return` implicite termine la méthode

Explication

Quand une méthode ne renvoie rien, un `return` implicite est ajouté à la fin de son corps. Un résultat entier n’est pas renvoyé, l’exécution ne continue pas après le corps, et aucun `return` explicite n’est requis dans cette situation.

48. Dans une méthode Java, que désigne une variable locale ?

Une variable définie dans une classe et accessible selon sa visibilité
Une variable commune aux méthodes et partagée pendant l’exécution
Une donnée transmise à une méthode et conservée après son invocation
Une variable définie dans une méthode et limitée à son invocation

Une variable définie dans une méthode et limitée à son invocation

Explication

Une variable locale est définie dans une méthode et n’existe que pendant l’invocation de cette méthode. Un champ de classe relève de la classe, un paramètre appartient à l’appel, et une variable partagée n’est pas une variable locale.

49. Lorsqu’une méthode Java est appelée, quel mécanisme l’environnement d’exécution met-il en place pour ses paramètres et ses variables locales ?

Il utilise un cadre commun qui conserve les paramètres de tous les appels
Il crée le cadre après l’exécution des paramètres et variables locales
Il crée un cadre d’appel qui contient les paramètres et les variables locales
Il ajoute les paramètres et variables locales au cadre de l’appelant

Il crée un cadre d’appel qui contient les paramètres et les variables locales

Explication

À chaque invocation, l’environnement crée un cadre d’appel et y place les paramètres et les variables locales; ce cadre est détruit à la fin de l’invocation. Un cadre commun ou le cadre de l’appelant ne correspond pas à ce mécanisme, et le cadre est créé au début de l’appel.

50. Une méthode appelée termine et renvoie une valeur à la méthode qui l’a appelée. Que se passe-t-il alors ?

Le cadre appelé est supprimé, celui de l’appelant redevient actif et l’exécution recommence au début de la méthode
Le cadre appelé reste actif, celui de l’appelant redevient inactif et l’exécution reprend avec la valeur renvoyée
Le cadre appelé est supprimé, celui de l’appelant est aussi détruit et l’exécution reprend avec la valeur renvoyée
Le cadre appelé est supprimé, celui de l’appelant redevient actif et l’exécution reprend avec la valeur renvoyée

Le cadre appelé est supprimé, celui de l’appelant redevient actif et l’exécution reprend avec la valeur renvoyée

Explication

À la sortie de la méthode appelée, son cadre est supprimé, le cadre de l’appelant redevient actif et l’exécution reprend avec la valeur de retour. Conserver le cadre appelé, détruire celui de l’appelant ou recommencer la méthode ne décrit pas cette reprise.

51. Une méthode reçoit un entier primitif et une référence vers un objet, puis modifie l’entier reçu et l’objet référencé. Quel effet ces modifications peuvent-elles avoir sur les données accessibles depuis l’appelant ?

L’entier original peut changer, mais l’objet référencé reste inchangé
L’entier original et l’objet référencé sont tous deux copiés et peuvent changer séparément
L’entier original reste inchangé, mais l’objet référencé peut être modifié
L’entier original et l’objet référencé restent inchangés

L’entier original reste inchangé, mais l’objet référencé peut être modifié

Explication

La copie d’une valeur primitive est indépendante de l’originale, tandis que la copie d’une référence permet à l’appelant et à l’appelé d’accéder au même objet. Croire que le primitif original change confond copie et partage; croire que l’objet est copié ou indépendant méconnaît le partage de la valeur référencée.

52. Dans une expression Java, une variable de type `short` est additionnée à une variable de type `char`. En quels types Java convertit-il ces valeurs avant l’opération arithmétique ?

En long pour les deux opérandes
En short pour les deux opérandes
En int pour les deux opérandes
En int pour le char et en short pour l’autre opérande

En int pour les deux opérandes

Explication

Avant une opération arithmétique, Java convertit les valeurs de type `byte`, `short` et `char` en `int`. Garder les types d’origine ou les promouvoir en `long` applique une règle différente; la conversion concerne aussi bien le `short` que le `char`.

53. Dans un programme Java, `c` est une variable de type `char`. Pourquoi l’affectation `char d = c + 1;` est-elle interdite sans conversion explicite ?

L’addition est interdite parce que c peut contenir une valeur négative
L’addition produit un int, qui ne se convertit pas implicitement en char
L’addition produit un long, qui ne se convertit pas implicitement en char
L’addition produit un char, qui ne se convertit pas implicitement en char

L’addition produit un int, qui ne se convertit pas implicitement en char

Explication

Une variable `char` est convertie en `int` pour l’opération arithmétique; l’expression `c + 1` produit donc un `int`, qu’on ne peut pas affecter implicitement à un `char`. L’expression ne produit pas un `char` ou un `long`, et l’interdiction ne tient pas au signe de `c`.

Révisez avec les flashcards

Mémorisez les réponses avec 91 flashcards sur Variables et structures en Java.

Par rapport à Python, pourquoi Java est-il présenté comme plus rapide à l’exécution ?

Grâce à la compilation en bytecode.

Quels thèmes le module « Java et algorithmique » aborde-t-il ?

La programmation impérative et orientée objet, les algorithmes de tri et de graphe, les arbres, les tables de hachage et les listes chaînées.

Dans l’exemple HelloWorld, à quoi sert le mot-clé `class` ?

À définir le nom du programme.

Voir les flashcards →

Approfondir avec la fiche

Consultez la fiche de révision complète sur Variables et structures 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