QCM : Fondamentaux de Java et objets — 64 questions

Explication

La programmation traditionnelle suit une approche descendante : elle part du problème global, sépare les données des traitements et construit une solution par décomposition. L’assemblage de composants unitaires correspond plutôt à la modélisation objet.

Explication

Une solution procédurale est généralement liée au problème initial, peu générique et peu réutilisable, car ses différentes parties sont fortement dépendantes. Les composants indépendants et réutilisables sont plutôt recherchés en conception objet.

Explication

La conception objet minimise l’information partagée afin de limiter les effets imprévus, puis favorise des composants indépendants du contexte et spécialisés. Une forte dépendance entre composants augmenterait au contraire les risques de propagation des erreurs.

Explication

Un objet possède un état, un comportement et une identité ; les termes objet et instance sont synonymes. Les opérations communes et la structure commune décrivent plutôt une classe, tandis que l’interface et l’implémentation concernent l’encapsulation.

Explication

Une classe décrit abstraitement un ensemble d’objets partageant une structure, des états et des opérations similaires. Un objet concret est une instance créée à partir de cette définition, tandis que le masquage relève de l’encapsulation.

Explication

L’instanciation est le mécanisme qui permet de créer un objet à partir de sa classe, et chaque objet est l’instance d’une seule classe. La relation entre classes générales et spécialisées relève plutôt de l’héritage.

Explication

L’encapsulation masque l’état et le fonctionnement interne d’un objet en distinguant l’interface, qui expose les services, de l’implémentation, qui les réalise. Le partage de données concerne les variables de classe, tandis que la poursuite de l’appelant caractérise un message asynchrone.

Explication

Les caractéristiques essentielles de l’orienté objet sont l’abstraction, l’encapsulation, la modularité et la hiérarchie. Cette dernière organise les abstractions selon une relation de type « est une sorte de ».

Explication

Un modèle représente le système informatique à réaliser et se construit par affinements successifs, depuis les éléments de la réalité jusqu’aux éléments informatiques réalisables. Les objets exécutés et les interfaces sont des éléments du système, pas la définition générale d’un modèle.

Explication

La modélisation objet construit le système de façon ascendante par assemblage de composants unitaires, contrairement à l’approche descendante de la programmation procédurale. La décomposition du problème global caractérise précisément cette dernière approche.

Explication

Java favorise la portabilité en traduisant les programmes en bytecode indépendant de la cible, interprété par une plateforme Java. Une compilation directe vers des instructions propres à chaque processeur dépendrait au contraire de la machine visée.

Explication

Le compilateur transforme les fichiers source en fichiers .class contenant le bytecode, tandis que l’interpréteur charge dynamiquement ces classes et exécute ce bytecode. La confusion fréquente consiste à attribuer la production du bytecode à l’interpréteur.

Explication

Un fichier Java peut contenir plusieurs classes, mais une seule peut être déclarée public et son nom doit correspondre exactement au nom du fichier sans l’extension. Le nombre de classes présentes n’interdit donc pas la présence d’une classe publique.

Explication

Une variable Java associe un nom à un type et doit être définie dans une classe. Java ne permet pas de déclarer une variable globale en dehors de toute classe.

Explication

La portée correspond à la zone du code où une variable est accessible ; elle peut concerner une variable locale, une variable d’instance, un paramètre de méthode ou un paramètre de gestionnaire d’exception. La valeur désigne plutôt le contenu détenu par la variable à un moment donné.

Explication

Une variable Java est caractérisée par un nom et un type, doit être définie dans une classe et reçoit par défaut 0 pour une valeur numérique ou null pour une référence d’objet. Une chaîne vide n’est pas la valeur par défaut générale des références.

Explication

Une variable locale final déclarée mais non encore initialisée est appelée blank final ; après son initialisation, sa valeur ne peut plus changer. Une variable ordinaire, contrairement à une variable final, peut être modifiée après son initialisation.

Explication

Le type char sert à représenter un caractère Unicode, alors que boolean représente une valeur logique pouvant être true ou false. Ces deux types ne décrivent donc pas respectivement un nombre réel et un entier.

Explication

Une expression combine notamment des variables, des opérateurs et des appels de méthodes, puis s’évalue en une valeur unique. Une structure contenant des éléments homogènes correspond plutôt à la définition d’un tableau.

Explication

Une instruction constitue une unité d’exécution complète, généralement terminée par un point-virgule, alors qu’un bloc regroupe zéro ou plusieurs instructions entre accolades. Les accolades caractérisent donc le bloc et non l’instruction individuelle.

Explication

L’opérateur == est un opérateur relationnel qui compare deux opérandes, ici x et 3. L’affectation utiliserait l’opérateur =, tandis que la création et le test de type relèvent respectivement de new et instanceof.

Explication

Les soustractions de même priorité s’associent de gauche à droite : $(1-2)-3=-1-3=-4$. Une évaluation de droite à gauche donnerait un autre résultat, mais elle ne correspond pas à la règle d’associativité de la soustraction.

Explication

La méthode main est invoquée automatiquement et doit être publique, statique, sans valeur de retour, avec un tableau de chaînes comme argument. Le mot-clé static indique qu’elle appartient à la classe, tandis que public concerne son accessibilité.

Explication

Une String peut être créée à partir d’un littéral ou d’un tableau de caractères ; length donne sa longueur et charAt accède à un caractère. Les autres propositions attribuent à String une origine, une mutabilité ou des méthodes qui ne correspondent pas à cette définition.

Explication

L’utilisation d’un Point nécessite d’abord une référence, puis une instanciation avec new, avant l’accès aux variables ou aux méthodes. Une déclaration de référence ne réserve pas à elle seule un objet en mémoire.

Explication

Une classe est un prototype d’objets qui définit un nouveau type et contient des variables et des méthodes comme membres. Une instance est un objet concret produit à partir de cette classe, et non la classe elle-même.

Explication

Un constructeur initialise l’état d’une instance, porte le nom de la classe et ne possède aucun type de retour ; plusieurs constructeurs peuvent être surchargés. Les méthodes ordinaires, elles, peuvent avoir un type de retour et un nom différent de celui de la classe.

Explication

Java fournit un constructeur par défaut lorsqu’aucun constructeur n’est défini. Dès qu’un constructeur explicite apparaît, ce comportement automatique disparaît ; il faut donc déclarer séparément un constructeur sans argument si nécessaire.

Explication

Une variable d’instance est propre à chaque objet, alors qu’une variable de classe est commune aux instances de cette classe. Confondre ces deux catégories inverse précisément leur mode de stockage et de partage.

Explication

Le mot-clé static associe le membre à la classe plutôt qu’à chaque objet, tandis que final interdit de modifier sa valeur après son initialisation. Ces mots-clés décrivent donc deux propriétés différentes, et non deux formes de partage.

Explication

Les arguments Java sont passés par valeur : la méthode reçoit une copie de la référence, qui permet d’atteindre et de modifier l’objet, mais pas de changer la référence originale. La réaffectation de cette copie ne modifie donc pas la variable de l’appelant.

Explication

String est destinée aux séquences de caractères immuables, alors que StringBuffer est conçue pour les séquences dont le contenu peut être modifié. La distinction repose donc sur la mutabilité, et non sur la portée ou la nature des caractères.

Explication

L’héritage permet de réutiliser du code existant, de s’appuyer sur des bibliothèques stables et de faciliter la maintenance. Il ne remplace pas la modélisation et ne bloque pas l’évolution du programme.

Explication

L’héritage est généralement introduit après le début de la modélisation, quand des ressemblances permettent de factoriser des attributs ou des méthodes. Le choisir avant l’analyse des classes ou pour assembler des composants correspond à une autre démarche.

Explication

Dans cette situation, l’héritage peut factoriser les éléments communs dans une classe générale. L’assemblage de composants relève plutôt de la composition, tandis que la duplication ou la suppression des éléments communs ne réalise pas cette factorisation.

Explication

En Java, une classe possède une seule superclasse directe, hérite par défaut de Object et ne peut appartenir à un cycle d’héritage. Les autres propositions contredisent ces contraintes structurelles.

Explication

La généralisation regroupe les propriétés communes de plusieurs classes dans une classe générale dont elles héritent. L’ajout de comportements propres décrit la spécialisation, tandis que la recherche d’une méthode et l’assemblage concernent d’autres mécanismes.

Explication

La spécialisation dérive une nouvelle classe en l’enrichissant de propriétés ou de comportements propres, ou en modifiant un comportement existant. Le regroupement des caractéristiques communes relève de la généralisation.

Explication

La relation d’héritage est pertinente si D constitue une sorte de B, de manière que ce qui est vrai pour B le soit aussi pour D. Une simple utilisation comme composant ou une différence de nom ne suffit pas à établir cette relation.

Explication

La recherche commence dans la classe de l’objet, puis remonte de superclasse en superclasse jusqu’à la première méthode qui convient. Elle ne commence donc ni par l’ancêtre le plus éloigné ni par les classes composantes.

Explication

La surcharge regroupe plusieurs méthodes de même nom dont les signatures diffèrent, alors que la redéfinition remplace une méthode héritée avec la même signature. Confondre ces notions revient à attribuer à la redéfinition le changement de paramètres propre à la surcharge.

Explication

Une méthode redéfinie conserve le nom, le type de résultat et la totalité des paramètres, tandis que son accès doit être identique ou moins restrictif. Rendre l’accès plus restrictif ou changer les paramètres empêcherait une véritable redéfinition.

Explication

La visibilité protected inclut les sous-classes et les classes du même package, alors que private reste confinée à la classe qui déclare le membre. Dire que private est accessible aux sous-classes confond cette visibilité avec celle de protected.

Explication

Le constructeur de la sous-classe doit appeler en premier celui de la superclasse, afin d’initialiser la partie héritée de l’objet. L’initialisation des attributs propres à la sous-classe intervient ensuite.

Explication

Le principe de substitution permet d’employer une instance de sous-classe là où une instance de superclasse est attendue. La conversion inverse, d’une superclasse vers une sous-classe, doit être demandée explicitement et peut être inappropriée.

Explication

Le polymorphisme permet d’envoyer une même opération à des objets d’une hiérarchie tout en exécutant un comportement adapté à leur classe réelle. Il ne demande donc pas de modifier le message ni de multiplier le code appelant.

Explication

Une interface spécifie des opérations et sert de contrat de service pour les classes qui l’implémentent, sans fournir leur implémentation complète. Elle ne joue donc pas le rôle d’un objet doté d’un état et d’un constructeur.

Explication

Java interdit qu’une classe étende plusieurs classes, mais autorise l’extension d’une classe accompagnée de l’implémentation de plusieurs interfaces. Les propositions autorisant plusieurs superclasses contredisent cette règle.

Explication

Object est la classe racine de la hiérarchie Java et définit les caractéristiques de base communes aux objets. Une classe Java n’a pas besoin d’être déclarée explicitement comme sous-classe pour appartenir à cette hiérarchie.

Explication

L’implémentation de equals dans Object repose sur l’identité : deux références sont égales lorsqu’elles désignent le même objet. Une classe peut redéfinir cette méthode pour adopter une comparaison fondée sur le contenu.

Explication

Le clonage décrit repose sur l’implémentation de Cloneable et sur l’appel à super.clone, qui crée un objet à partir de l’instance existante. Un constructeur ou new correspond à une création explicite différente du mécanisme demandé.

Explication

Le modificateur final appliqué à une classe interdit la création de sous-classes, tandis qu’il interdit la redéfinition lorsqu’il s’applique à une méthode. Il ne rend pas la classe abstraite et ne limite pas l’instanciation à une seule occurrence.

Explication

Une interface définit un contrat de service contenant notamment des déclarations de méthodes et des constantes implicitement publiques, statiques et finales. Elle ne constitue pas un espace destiné à stocker l’état privé partagé des objets.

Explication

La classe doit fournir une implémentation pour chaque méthode déclarée ou en hériter depuis une superclasse. La déclaration de méthodes statiques ne satisfait pas cette obligation d’implémentation.

Explication

Une méthode default fournit une implémentation que les classes existantes peuvent hériter lorsqu’une interface évolue. Elle ne transforme pas l’interface en classe instanciable et ne remplace pas toutes ses méthodes abstraites.

Explication

Lorsque deux méthodes default concurrentes créent une ambiguïté, la classe doit redéfinir la méthode et peut sélectionner une implémentation avec la syntaxe Interface.super.methode(). Une méthode default unique, en revanche, peut être héritée sans ce conflit.

Explication

Une lambda est une fonction anonyme utilisée comme raccourci syntaxique pour une interface fonctionnelle, qui possède une seule méthode abstraite. Elle n’est ni une classe abstraite ni une instruction de contrôle.

Explication

La syntaxe générale d’une lambda associe une liste de paramètres à un corps au moyen de la flèche, soit $\text{(paramètres)} \to \text{corps}$. La notation avec deux-points désigne une référence de méthode, et non une lambda.

Explication

Pour une lambda à un seul paramètre dont le type est inféré, les parenthèses sont facultatives. Elles restent nécessaires lorsque plusieurs paramètres sont présents ou lorsque la syntaxe exige de préciser les types.

Explication

Function utilise apply pour transformer une valeur et retourner un résultat. Predicate utilise test pour produire un booléen, Supplier utilise get pour fournir une instance et Consumer utilise accept pour effectuer une action sans retour.

Explication

Une référence de méthode simplifie l’utilisation d’une méthode ou d’un constructeur dans le contexte d’une interface fonctionnelle et emploie l’opérateur ::. Elle ne transforme pas les méthodes d’instance en méthodes statiques.

Explication

La notation $\text{NomClasse} :: \text{new}$ désigne un constructeur. La forme $\text{NomClasse} :: \text{nomMethode}$ peut, selon le contexte, désigner une méthode statique ou une méthode d’un objet arbitraire.

Explication

Une importation permet d’utiliser directement le nom court de l’élément importé plutôt que son chemin complet. Elle ne remplace pas le nom de l’élément par celui du fichier compilé ou du répertoire racine.

Explication

La compilation crée un fichier .class pour chaque classe définie et le place dans une arborescence correspondant au package. Le fichier .java est le fichier source, tandis que le fichier .class contient le résultat compilé.