QCM : Programmation orientée objet en Java (41 questions)

Questions et réponses du QCM

1. Dans un programme de gestion d’école, quelle démarche correspond à la programmation orientée objet ?

Représenter les informations des utilisateurs à l’aide de variables
Représenter les étapes du programme à l’aide de méthodes
Représenter les résultats du programme à l’aide de fichiers
Représenter les choses du problème à l’aide de classes

Représenter les choses du problème à l’aide de classes

Explication

La programmation orientée objet modélise les choses présentes dans le problème en utilisant des classes. Les méthodes décrivent plutôt des actions, les variables des informations et les fichiers des données conservées.

2. Une classe `Voiture` prévoit une marque et une couleur, mais aucune voiture précise n’a encore été créée. Quel rôle joue cette classe ?

Une action que chaque voiture peut exécuter
Un modèle décrivant les informations prévues pour les voitures
Une valeur précise attribuée à la marque d’une voiture
Une voiture particulière contenant déjà ses propres valeurs

Un modèle décrivant les informations prévues pour les voitures

Explication

Une classe décrit le modèle et les informations attendues pour les objets correspondants, sans désigner à elle seule un objet précis. Une voiture particulière est une instance, une action relève d’une méthode et une valeur concrète appartient à un attribut.

3. Dans une classe `Film`, la variable `duree` est déclarée à l’intérieur de la classe et indique la durée de chaque film. Comment faut-il la qualifier ?

Un attribut représentant une information du film
Une classe décrivant le modèle des films
Une méthode exécutant une action du film
Un objet créé à partir de la classe Film

Un attribut représentant une information du film

Explication

Une variable déclarée dans une classe qui représente une information de l’objet est un attribut. Une action est une méthode, une instance est un objet créé à partir de la classe et le modèle est la classe elle-même.

4. Deux instances de la classe `Etudiant` sont créées, l’une avec le nom « Léa », l’autre avec le nom « Sami ». Qu’est-ce qui caractérise chacune d’elles ?

C’est une variable qui ne contient aucune instance
C’est un objet issu de la classe, avec ses propres valeurs d’attributs
C’est une valeur d’attribut commune aux deux étudiants
C’est le modèle de classe, partagé comme une valeur unique

C’est un objet issu de la classe, avec ses propres valeurs d’attributs

Explication

Un objet est une instance créée à partir d’une classe et possède ses propres valeurs d’attributs. La classe est le modèle commun, tandis que les noms Léa et Sami illustrent des valeurs propres à chaque objet.

5. Dans la classe `Etudiant`, la fonction `sePresenter()` affiche une phrase à propos de l’étudiant. De quel type d’élément s’agit-il ?

Une méthode, c’est-à-dire une action que l’objet peut effectuer
Un attribut, c’est-à-dire une information portée par l’objet
Une classe, c’est-à-dire le modèle des étudiants
Un objet, c’est-à-dire une instance créée à partir de la classe

Une méthode, c’est-à-dire une action que l’objet peut effectuer

Explication

Une méthode est une action qu’un objet peut effectuer et elle est écrite dans sa classe. Un attribut représente une information, tandis que l’objet est l’instance et la classe son modèle.

6. Une étudiante est référencée par `e1` et sa classe contient la méthode `sePresenter()`. Quelle écriture demande à cet objet d’exécuter cette méthode ?

`new Etudiant();`
`sePresenter.e1();`
`e1.sePresenter();`
`e1.sePresenter;`

`e1.sePresenter();`

Explication

Le point après le nom de l’objet permet d’appeler sa méthode : `e1.sePresenter();` demande à `e1` de l’exécuter. `e1.sePresenter` omet l’appel, l’ordre inversé ne désigne pas correctement l’objet, et `new Etudiant()` crée une instance.

7. Dans un programme, `sePresenter()` est écrite une fois dans la classe `Etudiant`, puis appelée sur deux étudiants dont les noms sont différents. Que se passe-t-il ?

Chaque étudiant exécute la même méthode avec ses propres informations
Les deux étudiants exécutent la méthode avec des informations communes
La méthode crée une nouvelle instance à chaque appel
Un seul étudiant peut exécuter la méthode écrite dans la classe

Chaque étudiant exécute la même méthode avec ses propres informations

Explication

Une méthode peut être définie une fois et exécutée par plusieurs objets, chacun utilisant ses propres informations. La copie de la méthode par objet n’est pas nécessaire, les attributs ne deviennent pas communs et l’appel n’est pas en lui-même une création d’objet.

8. Lorsqu’un objet `Commande` est créé, quel rôle joue son constructeur dans cette situation ?

Définir les actions que l’objet peut effectuer
Donner leurs valeurs de départ aux attributs
Afficher les valeurs des attributs à l’écran
Créer la classe à partir de l’objet

Donner leurs valeurs de départ aux attributs

Explication

Le constructeur initialise les attributs au moment où l’objet est créé. Afficher des valeurs relève d’une action, tandis que le constructeur ne crée pas la classe elle-même.

9. Une classe `Produit` doit déclarer un constructeur valide. Quelle déclaration respecte les règles de nom et de type de retour ?

`Produit(String nom)`
`void Produit(String nom)`
`String Produit(String nom)`
`Article(String nom)`

`Produit(String nom)`

Explication

Un constructeur porte le même nom que sa classe et ne déclare aucun type de retour, pas même `void`. Ajouter `void` ou `String` en fait une méthode, et `Article` ne correspond pas au nom de la classe.

10. Une classe `Etudiant` a déclaré le constructeur `Etudiant(String nom, int age)`. Quel appel convient pour créer un objet avec ce constructeur ?

`new Etudiant(19, "Lina")`
`new Etudiant("Lina", 19)`
`new Etudiant()`
`new Etudiant("Lina")`

`new Etudiant("Lina", 19)`

Explication

Après la déclaration d’un constructeur à paramètres, l’appel doit fournir les arguments attendus, ici un nom et un âge. L’appel sans argument, l’argument manquant ou l’ordre inversé ne respecte pas cette signature.

11. Dans le constructeur `Etudiant(String nom) { this.nom = nom; }`, quelle interprétation de l’affectation est correcte ?

L’attribut reçoit la valeur d’un autre attribut
L’attribut reçoit la valeur du paramètre
Le paramètre reçoit la valeur de l’attribut
Le paramètre reçoit la valeur d’un autre paramètre

L’attribut reçoit la valeur du paramètre

Explication

Dans `this.nom = nom`, `this.nom` désigne l’attribut de l’objet et `nom` désigne le paramètre reçu par le constructeur. Inverser ces rôles ou interpréter les deux termes comme des attributs ou des paramètres confond leur fonction.

12. Dans un programme, `Film` décrit des attributs, et `film1` est créé à partir de cette définition. Quelle distinction s’applique ?

`Film` est le modèle et `film1` un exemplaire
`Film` est une valeur et `film1` un attribut
`Film` est un constructeur et `film1` une classe
`Film` est un exemplaire et `film1` le modèle

`Film` est le modèle et `film1` un exemplaire

Explication

Une classe sert de modèle, tandis qu’un objet est un exemplaire créé à partir de ce modèle. Traiter `film1` comme le modèle confond l’objet avec la classe; attribut et constructeur sont d’autres notions.

13. Une équipe modélise une application de cinéma en créant des classes pour ses éléments, puis des objets à partir de ces classes. Quelle démarche décrit-elle ?

Créer des méthodes représentant l’application, puis leurs attributs
Créer des variables représentant l’application, puis leurs méthodes
Créer des objets représentant l’application, puis leurs classes
Créer des classes représentant l’application, puis leurs objets

Créer des classes représentant l’application, puis leurs objets

Explication

La programmation orientée objet consiste à représenter les éléments d’une application par des classes, puis à créer des objets à partir de celles-ci. Commencer par les objets et en déduire les classes inverse cette démarche; variables et méthodes ne constituent pas à elles seules le modèle décrit.

14. Dans une classe `Voiture`, laquelle de ces notions désigne une action que l’objet peut effectuer, plutôt qu’une information qui lui appartient ?

Un objet comme `maVoiture`
Un attribut comme `couleur`
Une méthode comme `freiner()`
Une valeur comme `rouge`

Une méthode comme `freiner()`

Explication

Une méthode représente une action que l’objet peut effectuer, tandis qu’un attribut contient une information appartenant à l’objet. `couleur` est un attribut, `rouge` une valeur et `maVoiture` un objet.

15. Un programme doit créer un nouvel objet de la classe `Etudiant`. Quelle instruction réalise cette création ?

`Etudiant.new()`
`Etudiant()`
`Etudiant`
`new Etudiant()`

`new Etudiant()`

Explication

Le mot-clé `new` crée un nouvel objet à partir d’une classe ; sans lui, aucun objet n’est créé. `Etudiant` désigne la classe, et `Etudiant()` omet le mot-clé de création.

16. L’objet `e1` possède l’attribut `nom` et la méthode `sePresenter()`. Quelle paire d’expressions accède à l’attribut puis appelle la méthode ?

`e1.nom` puis `e1.sePresenter()`
`nom.e1` puis `sePresenter().e1`
`e1.nom()` puis `e1.sePresenter()`
`e1.nom` puis `e1.sePresenter`

`e1.nom` puis `e1.sePresenter()`

Explication

Le point permet d’accéder à un attribut sous la forme `objet.attribut` et d’appeler une méthode sous la forme `objet.methode()`. Les parenthèses après `nom` le traiteraient comme une méthode, tandis que leur omission empêcherait l’appel de `sePresenter()`.

17. Dans une classe de compte bancaire, quelle conception protège les données tout en encadrant les modifications du solde ?

Interdire toute modification des attributs après la création de l’objet
Autoriser la lecture par des méthodes sans contrôler les changements
Rendre les attributs accessibles à tous et laisser chaque appelant les modifier
Cacher les attributs et faire valider les changements par des méthodes

Cacher les attributs et faire valider les changements par des méthodes

Explication

L’encapsulation protège les attributs et fait passer leurs modifications par des méthodes qui vérifient les règles. Un accès libre contourne ces contrôles, tandis qu’interdire tout changement ou ne permettre que la lecture ne correspond pas à cette définition.

18. Une classe `Dossier` doit garder son attribut `secret` accessible à ses propres méthodes, mais inaccessible aux autres classes. Quel niveau d’accès convient à `secret` ?

`public`
`static`
`protected`
`private`

`private`

Explication

En Java, `private` réserve l’accès à l’intérieur de la classe, alors que `public` rend l’élément accessible depuis n’importe quelle classe. `static` caractérise un membre de classe et ne définit pas cette restriction d’accès.

19. Une classe expose un attribut privé `age` : une méthode publique doit le lire, et une autre doit le modifier après avoir vérifié la nouvelle valeur. Quelle paire de méthodes faut-il prévoir ?

Un setter pour lire et un getter contrôlé pour modifier
Un getter pour lire et un setter contrôlé pour modifier
Deux getters, l’un pour lire et l’autre pour modifier
Deux setters, l’un pour lire et l’autre pour modifier

Un getter pour lire et un setter contrôlé pour modifier

Explication

Un getter public lit un attribut privé, tandis qu’un setter public le modifie après avoir vérifié que la nouvelle valeur est acceptable. Inverser leurs rôles ou utiliser deux méthodes de même type ne respecte pas cette distinction.

20. Le solde d’un compte est de 80 euros et la méthode `retirer` reçoit une demande de 95 euros. Quel résultat la règle de retrait impose-t-elle ?

Refuser le retrait et porter le solde à zéro euro
Accepter le retrait et conserver le solde à 80 euros
Accepter le retrait et porter le solde à −15 euros
Refuser le retrait et conserver le solde à 80 euros

Refuser le retrait et conserver le solde à 80 euros

Explication

`retirer` refuse un montant supérieur au solde disponible ; comme 95 euros dépassent 80 euros, le solde reste inchangé. Le solde négatif enfreint cette règle, et le ramener à zéro ne correspond pas au refus sans modification.

21. Dans une classe `Compteur`, `total` est déclaré `static`. Après la création de deux objets, quelle propriété décrit cet attribut ?

Chaque classe dérivée possède une valeur distincte de `total`.
Chaque objet possède sa propre valeur de `total`.
La valeur de `total` n’existe que pendant une méthode.
Les deux objets partagent la même valeur de `total`.

Les deux objets partagent la même valeur de `total`.

Explication

Un attribut `static` appartient à la classe et son exemplaire est partagé par tous ses objets. L’attribut d’instance est propre à chaque objet, une classe dérivée ne crée pas nécessairement son propre compteur et une variable locale a une portée différente.

22. Une méthode `static` appelée sans créer d’objet tente d’appeler directement `afficher()`, une méthode non `static`. Quelle modification permet de respecter la règle Java ?

Créer un objet puis appeler `afficher()` sur cet objet.
Déplacer l’appel dans une autre méthode `static` sans créer d’objet.
Ajouter un attribut `static` sans modifier l’appel à `afficher()`.
Appeler `afficher()` directement depuis la méthode `static`.

Créer un objet puis appeler `afficher()` sur cet objet.

Explication

Une méthode `static` ne désigne aucun objet particulier et ne peut donc pas appeler directement une méthode non `static`; il faut passer par une instance. L’appel direct et le déplacement vers une autre méthode `static` ne fournissent toujours pas d’objet, et un attribut `static` ne change pas la nature de `afficher()`.

23. Une application modélise un étudiant, qui possède les caractéristiques communes d’une personne et ajoute une filière. Quelle conception applique l’héritage Java ?

Déclarer `Etudiant extends Personne` sans pouvoir ajouter de membre.
Ajouter un objet `Personne` dans `Etudiant` sans utiliser `extends`.
Déclarer `Personne extends Etudiant`, puis ajouter la filière.
Déclarer `Etudiant extends Personne`, puis ajouter la filière.

Déclarer `Etudiant extends Personne`, puis ajouter la filière.

Explication

L’héritage permet à la classe fille de recevoir attributs et méthodes de la classe mère, puis d’ajouter ses propres éléments; Java l’exprime avec `extends`. Inverser les classes renverse la relation, contenir une `Personne` relève de la composition, et l’héritage autorise bien l’ajout de membres.

24. Le constructeur de `Etudiant` doit initialiser `nom` et `age` avec le constructeur de `Personne`. Quelle instruction doit figurer en première ligne du constructeur de `Etudiant` ?

`this(nom, age);`
`super();`
`super(nom, age);`
`new Personne(nom, age);`

`super(nom, age);`

Explication

Le constructeur de la classe fille appelle celui de sa classe mère avec `super(nom, age)`, et cet appel doit être la première ligne. `this` appelle un autre constructeur de la même classe, `new Personne` crée un objet séparé et `super()` ne transmet pas les arguments requis.

25. Une classe `Vehicule` définit `demarrer()`. Quelle méthode une classe fille doit-elle écrire pour redéfinir cette méthode selon les règles de Java ?

Une méthode `demarrer(int puissance)` annotée `@Override`.
Une méthode `demarrer()` avec une signature différente et un nouveau nom.
Une méthode `demarrer()` avec la même signature, éventuellement annotée `@Override`.
Une méthode `@Override` sans réécrire la méthode héritée.

Une méthode `demarrer()` avec la même signature, éventuellement annotée `@Override`.

Explication

La redéfinition réécrit la méthode héritée en conservant la même signature ; `@Override` permet de signaler cette intention à Java. Ajouter un paramètre crée une surcharge, tandis qu’une annotation sans méthode réécrite ne réalise pas la redéfinition.

26. Une variable de type `Animal` désigne successivement un objet `Chien` puis un objet `Chat`, chacun redéfinissant `crier()`. Que se passe-t-il lors du même appel `animal.crier()` sur ces deux objets ?

Les deux objets exécutent la version définie dans `Animal`.
Les deux objets exécutent la version de `crier()` définie dans `Chien`.
Chaque objet exécute la version de `crier()` correspondant à sa classe réelle.
Chaque objet exécute à la fois la version de sa classe et celle de `Animal`.

Chaque objet exécute la version de `crier()` correspondant à sa classe réelle.

Explication

Le polymorphisme fait dépendre la version exécutée de la classe réelle de l’objet visé par l’appel. Se fier au type déclaré `Animal` confond type de référence et classe réelle ; les versions ne se combinent pas automatiquement, et la méthode de `Chien` ne s’applique pas à `Chat`.

27. Une équipe veut définir `Forme`, qui fournit une base commune mais ne correspond pas à un objet concret à créer. Quelle déclaration convient ?

Déclarer `Forme` comme classe concrète, puis créer des objets génériques.
Déclarer `Forme` comme classe abstraite, sans l’instancier directement.
Déclarer `Forme` comme classe abstraite, mais sans méthode abstraite possible.
Déclarer `Forme` comme interface, car elle peut contenir des méthodes abstraites.

Déclarer `Forme` comme classe abstraite, sans l’instancier directement.

Explication

Une classe abstraite ne peut pas être instanciée et peut contenir des méthodes abstraites, ce qui convient à une base commune sans forme concrète. Une classe concrète peut être instanciée ; une interface n’est pas une classe abstraite, et celle-ci peut bien contenir des méthodes abstraites.

28. La classe abstraite `Forme` déclare une méthode abstraite `aire()`. Quel code une classe fille concrète doit-elle fournir pour satisfaire cette déclaration ?

Une implémentation de `aire()` avec un corps dans la classe fille.
Une déclaration `aire()` avec un corps dans la classe mère abstraite.
Une déclaration `aire();` sans corps dans la classe fille concrète.
Une méthode `calculerAire()` avec un corps dans la classe fille.

Une implémentation de `aire()` avec un corps dans la classe fille.

Explication

Une méthode abstraite est déclarée sans corps et se termine par un point-virgule ; une classe fille concrète doit en fournir l’implémentation. Laisser la méthode sans corps ne satisfait pas cette obligation, et un autre nom ne correspond pas à la méthode héritée.

29. Dans une application, quelle fonction remplit une interface ?

Créer un objet concret qui exécute les méthodes déclarées
Définir une classe mère dont les sous-classes héritent des attributs
Énumérer les méthodes qu’une classe s’engage à fournir sans décrire leur réalisation
Fournir le code détaillé des méthodes qu’une classe doit réutiliser

Énumérer les méthodes qu’une classe s’engage à fournir sans décrire leur réalisation

Explication

Une interface définit un contrat en listant les méthodes attendues, sans préciser leur réalisation. Le code détaillé relève de l’implémentation, les attributs hérités d’une classe mère et l’objet concret d’une instanciation.

30. Une classe `Rapport` déclare `implements Imprimable`. Que doit faire son auteur pour respecter ce contrat ?

Écrire une méthode au choix parmi celles de `Imprimable`
Laisser le compilateur générer les méthodes de `Imprimable`
Écrire toutes les méthodes déclarées par `Imprimable`
Étendre `Imprimable` et hériter de ses méthodes concrètes

Écrire toutes les méthodes déclarées par `Imprimable`

Explication

Une classe qui signe une interface avec `implements` doit écrire toutes les méthodes de son contrat. `extends` concerne l’héritage de classe, tandis qu’une implémentation partielle exige que la classe soit déclarée abstraite.

31. Une équipe conçoit des classes très différentes qui doivent toutes pouvoir exporter un fichier, sans partager d’attributs ni de code commun. Quel choix correspond le mieux à ce besoin ?

Une interface qui définit la capacité d’exporter
Une classe concrète qui impose un constructeur commun
Une classe abstraite qui fournit un état partagé
Une classe mère qui représente une relation « est un »

Une interface qui définit la capacité d’exporter

Explication

Une interface convient lorsque des classes distinctes partagent une capacité, ici exporter, sans partager de code. Une classe abstraite sert plutôt à représenter une relation « est un » et peut mutualiser attributs, constructeur et méthodes.

32. Une classe Java possède déjà une classe mère et doit également respecter les contrats `Imprimable` et `Exportable`. Quelle conception est permise ?

Étendre sa classe mère et choisir une seule des deux interfaces
Étendre sa classe mère et implémenter les deux interfaces
Étendre les deux interfaces et abandonner sa classe mère
Conserver sa classe mère sans pouvoir implémenter d’interface

Étendre sa classe mère et implémenter les deux interfaces

Explication

Une classe Java ne peut avoir qu’une seule classe mère, mais elle peut implémenter autant d’interfaces qu’elle le souhaite. Limiter les interfaces à une seule confond leur règle avec celle de l’héritage de classes.

33. Pour gérer un catalogue dont le nombre de livres varie, quelle caractéristique décrit un `ArrayList<Livre>` ?

Un tableau de taille fixe qui stocke les livres sans possibilité d’ajout
Une liste qui grandit automatiquement et permet d’ajouter, compter et parcourir les livres
Une liste de taille variable qui ne permet pas de parcourir les livres
Un objet Livre unique qui mémorise le nombre total de livres

Une liste qui grandit automatiquement et permet d’ajouter, compter et parcourir les livres

Explication

Un `ArrayList<Livre>` grandit automatiquement et permet d’ajouter des éléments, d’obtenir sa taille et de les parcourir. Un tableau de taille fixe ne correspond pas à cette caractéristique, et la liste contient des éléments plutôt qu’un seul objet.

34. Le total des produits d’un panier est de 1 200 roupies. Quelle somme `totalAvecRemise()` doit-elle renvoyer si la remise de 10 % s’applique lorsque le total dépasse 1 000 roupies ?

1 190 roupies
1 200 roupies
1 080 roupies
972 roupies

1 080 roupies

Explication

Le total dépasse le seuil : la remise vaut 10 % de 1 200, soit 120 roupies, et le montant après remise est donc 1 200 − 120 = 1 080 roupies. Soustraire 10 roupies confond pourcentage et montant fixe, et appliquer deux remises réduit le montant à tort.

35. Une séance compte 6 places restantes. Que fait `reserver(7)` ?

Renvoie `false` et laisse 5 places restantes
Renvoie `false` sans modifier les places restantes
Renvoie `true` et laisse 13 places restantes
Renvoie `true` et laisse 0 place restante

Renvoie `false` sans modifier les places restantes

Explication

Une demande supérieure au nombre de places restantes est refusée et ne modifie pas ce nombre. La décrémentation malgré le refus confond contrôle et mise à jour; l’acceptation d’une demande trop grande ignore la limite.

36. Une séance dispose de 9 places et une réservation valide en demande 4. Quel est le résultat de `reserver(4)` ?

Renvoie `false` et laisse 5 places restantes
Renvoie `true` et laisse 13 places restantes
Renvoie `true` et laisse 9 places restantes
Renvoie `true` et laisse 5 places restantes

Renvoie `true` et laisse 5 places restantes

Explication

Pour une réservation valide, la méthode soustrait le nombre demandé des places restantes et renvoie `true`. Ajouter les places inverse l’opération, tandis que conserver le compteur omet la mise à jour.

37. Une liste contient des employés fixes et des freelances. Quel traitement permet d’afficher le salaire de chacun dans une même boucle ?

Choisir le calcul du freelance pour toute la liste
Appeler `salaire()` sur chaque employé de la liste
Créer une boucle distincte pour chaque type d’employé
Calculer un salaire identique à partir du nom de chacun

Appeler `salaire()` sur chaque employé de la liste

Explication

Le polymorphisme permet d’appeler `salaire()` sur des employés de types différents au sein d’une même boucle. Des boucles séparées renoncent à ce traitement commun, et un calcul uniforme ne respecte pas les différences entre types.

38. Un freelance travaille 18 heures à 40 € l’heure. Quel salaire obtient-on avec la règle de calcul applicable ?

720 €
720 € plus 5 % des ventes
40 €
58 €

720 €

Explication

Le salaire d’un freelance est le produit des heures et du taux horaire : 18×40=72018 \times 40 = 720 €. L’addition confond les opérations, et la commission relève du calcul des commerciaux, non de celui des freelances.

39. Un étudiant appelle `ajouterNote` avec les valeurs 0, 20 et 21. Quelles valeurs sont ajoutées à la liste privée ?

0 et 20
Aucune des trois valeurs
0, 20 et 21
20 et 21

0 et 20

Explication

La méthode accepte les notes de 0 à 20 inclus et refuse celles qui dépassent ces bornes. L’exclusion des bornes confond l’intervalle inclusif avec un intervalle ouvert, tandis que l’ajout de 21 ignore la limite supérieure.

40. Une liste contient les notes 12, 15 et 18. Quelle moyenne la méthode renvoie-t-elle ?

14
15,5
15
45

15

Explication

La moyenne est la somme des notes divisée par leur nombre : (12+15+18)/3=15(12+15+18)/3=15. 14 correspond à une division par deux, 15,5 confond moyenne et médiane, et 45 est la somme non divisée.

41. Après le calcul de sa moyenne, un étudiant obtient 14,0 sur 20. Quelle mention reçoit-il ?

Assez bien
Passable
Bien
Très bien

Bien

Explication

La mention Bien s’applique à partir de 14, tandis que Très bien commence à 16. Assez bien correspond au seuil de 12 et Passable à celui de 10; traiter 14 comme inférieur au seuil de Bien méconnaît le seuil inclusif.

Révisez avec les flashcards

Mémorisez les réponses avec 92 flashcards sur Programmation orientée objet en Java.

Que représente la programmation orientée objet dans un programme ?

Les choses du problème à l’aide de classes.

Qu’est-ce qu’une classe décrit pour les objets correspondants ?

Les informations prévues pour ces objets.

Qu’est-ce qu’un attribut représente dans un objet ?

Une information de l’objet.

Voir les flashcards →

Approfondir avec la fiche

Consultez la fiche de révision complète sur Programmation orientée objet 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