Test qcm Programmation Orientée Objet -Concours QCM

Ce document académique propose un Questionnaire à Choix Multiples (QCM) corrigé sur la Programmation Orientée Objet (POO) en Java, datant de 2005. Il est destiné aux étudiants universitaires en informatique désireux d'évaluer et de consolider leurs connaissances de ce langage.

Il couvre les notions suivantes :

Les principes fondamentaux de la POO (polymorphisme, encapsulation, héritage) ;
Le fonctionnement de la Machine Virtuelle Java (JVM) et la gestion des objets ;
Les constructeurs, le passage de paramètres et les interfaces.

Une section FAQ complète ce QCM pour éclaircir les points essentiels et faciliter la révision.

Exercices TD Programmation Orientée Objet -Concours QCM

Télécharger PDF

QCM de POO 2005 corrigé

Section 1. Questions générales

Bonne réponse = 1 pt ; mauvaise réponse = -0.5 pt ; pas de réponse = 0 pt.

L'interprétation des programmes Java est effectuée par
- (a) API
- (b) JDK
- (c) JVM
- (d) AWT
La machine virtuelle Java (JVM) interprète le bytecode des programmes Java.
Trouver la phrase qui n'est pas une caractérisation correcte du polymorphisme :
- (a) le polymorphisme est un mécanisme consistant à rassembler les données et les méthodes au sein d’une structure en cachant l’implémentation de l’objet.
- (b) le polymorphisme signifie que la même opération peut se comporter différemment sur différentes classes de la hiérarchie.
- (c) le polymorphisme offre la possibilité à plusieurs objets de natures différentes d’exposer une interface identique au système, et ainsi répondre à un même message d’une manière qui leur est propre.
- (d) le polymorphisme consiste à autoriser le même code à être utilisé avec différents types, ce qui permet des implémentations plus abstraites et générales.
La première phrase est en fait une définition de l'encapsulation, les trois autres décrivent divers aspects du polymorphisme.
Laquelle des opérations ci-dessus est interdite en Java ?
- (a) le upcasting implicite
- (b) le upcasting explicite
- (c) le downcasting implicite
- (d) le downcasting explicite
Le downcasting est une opération risquée et le programmeur doit la demander explicitement. Le downcasting implicite est interdit en Java.
Quelle classe n'a pas de classe mère ?
- (a) Orpheline
- (b) String
- (c) Object
- (d) une classe abstraite
La classe Object est l'ancêtre de toutes les autres classes en Java. Toutes les autres classes en héritent directement ou indirectement.
Qu'est-ce qui est faux pour les interfaces ?
- (a) Une interface peut être le type d’une référence
- (b) Une interface déclare des méthodes sans les implémenter
- (c) Une interface peut être implémentée
- (d) Une interface peut être instanciée
L'instanciation est impossible pour les interfaces car elles ne fournissent pas d'implémentation complète ; tout le reste est autorisé.

Section 2. Questions spécifiques

Bonne réponse = 3 pt ; mauvaise réponse = -1 pt ; pas de réponse = 0 pt.

Pour les classes A et D définies comme suit :
```
class A {
    public static int f(int x) {return(x+5) ; }
    public int g(int x) {return (3) ; }
}

class D extends A {
    public static int f(int x) {return(x+4) ; }
    public int g(int x) {return (x+8) ; }
}
```
Qu’affichera le code suivant ?
```
D d=new D() ;
A a =d ;
System.out.println(a.f(2)*a.g(3)) ;
```
- (a) 18
- (b) 21
- (c) 66
- (d) 77
La méthode f() est statique, donc sa résolution se fait à la compilation basée sur le type de la référence. Ici, la référence a est de type A, donc a.f(2) appelle la méthode f(int x) de la classe A, ce qui donne 2+5 = 7. La méthode g() est une méthode d'instance (dynamique), sa résolution se fait à l'exécution basée sur le type réel de l'objet. L'objet référencé par a est une instance de D, donc a.g(3) appelle la méthode g(int x) de la classe D, ce qui donne 3+8 = 11. Le résultat final est 7 * 11 = 77.
On définit la méthode permuter
```
public static void permuter (String s1, String s2, int x1, int x2){
    String tmp1=s1 ;
    s1=s2 ;
    s2=tmp1 ;
    int tmp2=x1 ;
    x1=x2 ;
    x2=tmp2 ;
}
```
On l’applique dans le contexte suivant :
```
String a="bon" ;
String b="jour" ;
int c=3 ;
int d =4 ;
permuter(a,b,c,d) ;
```
Quelles seront les valeurs de a,b,c,d après l’exécution de ce code ?
- (a) "bon", "jour", 3, 4
- (b) "jour", "bon", 3, 4
- (c) "bon", "jour", 4, 3
- (d) "jour", "bon", 4, 3
En Java, les paramètres sont passés par valeur. Pour les types primitifs (comme int) et les références d'objets (comme String), cela signifie que la méthode permuter reçoit des copies des valeurs des variables a, b, c, et d. Toute modification de s1, s2, x1, x2 à l'intérieur de la méthode permuter n'affecte donc pas les variables originales a, b, c, d de l'appelant. Leurs valeurs restent inchangées après l'exécution de la méthode.
Pour la classe D définie comme suit :
```
class D {
    public int x ;
    public D() {x=3 ; }
    public D( int a){this() ; x=x+a ;}
    public D( int a, int b){this(b) ; x= x-a ;}
}
```
Qu’affichera le code suivant ?
```
D a=new D(5,6) ;
System.out.println(a.x) ;
```
- (a) 1
- (b) 2
- (c) 3
- (d) 4
Pour comprendre le résultat, il faut suivre la chaîne des appels de constructeurs :
1. L'appel new D(5,6) exécute le constructeur D(int a, int b).
2. Ce constructeur appelle this(b), c'est-à-dire this(6), exécutant le constructeur D(int a).
3. Le constructeur D(int a) appelle this(), exécutant le constructeur par défaut D().
4. Dans D(), x est initialisé à 3.
5. Le contrôle revient à D(int a) (avec a=6). L'instruction x = x + a devient x = 3 + 6, donc x est maintenant 9.
6. Le contrôle revient à D(int a, int b) (avec a=5, b=6). L'instruction x = x - a devient x = 9 - 5, donc x est maintenant 4.
Le code affichera donc 4.
Étant donné que la classe Triangle étend la classe Figure, trouvez une ligne correcte parmi les suivantes :
- (a) Triangle x= new Triangle() ; Object y = (Object)x ; Triangle z=y ;
  La troisième instruction, Triangle z=y;, est un downcasting implicite. En Java, le downcasting doit être explicite, ce qui provoque une erreur de compilation.
- (b) Figure y =new Figure() ; Triangle x= (Triangle)y ; Figure z=x ;
  La compilation réussit sans erreur. Cependant, à l'exécution, la deuxième instruction Triangle x= (Triangle)y; (un downcasting explicite) échoue avec une ClassCastException car l'objet référencé par y est une Figure et non un Triangle au moment de la création.
- (c) Triangle x= new Triangle() ; Figure y = x ; Triangle z=(Triangle)y ;
  Ici, toutes les opérations sont valides. L'objet créé est un Triangle. La deuxième instruction effectue un upcasting implicite (Figure y = x;) qui est toujours sûr. La troisième instruction réalise un downcasting explicite (Triangle z=(Triangle)y;) qui réussit car l'objet sous-jacent référencé par y est bien un Triangle.
- (d) Figure y =new Figure() ; Triangle x= (Triangle)y ; Figure z=(Figure)x ;
  Semblable à l'option (b), la compilation réussit, mais la deuxième instruction Triangle x= (Triangle)y; génère une ClassCastException à l'exécution car y référence une Figure qui n'est pas un Triangle.
Pour la classe définie comme suit :
```
public class Bidon {int x ;}
```
Lequel des programmes est faux ?
- (a) Bidon a=new Bidon(3) ;
- (b) Bidon a=new Bidon() ; String s=a.toString() ;
- (c) Bidon a=new Bidon() ; boolean b= a.equals("bonjour") ;
- (d) Bidon a=new Bidon() ; boolean b= a.equals(a) ;
L'option (a) Bidon a=new Bidon(3); tente d'appeler un constructeur Bidon(int) qui n'est pas défini dans la classe Bidon. La classe ne contient qu'un constructeur par défaut implicite (sans paramètres). Toutes les autres options utilisent des méthodes (toString(), equals()) héritées de la classe Object, qui est l'ancêtre de toutes les classes en Java, et sont donc valides.

FAQ

1. Qu'est-ce que le polymorphisme en Java ?

Le polymorphisme en Java permet à une méthode d'avoir plusieurs formes. Cela signifie que la même méthode peut se comporter différemment selon le type de l'objet sur lequel elle est appelée.

2. Quelle est la différence entre upcasting et downcasting ?

L'upcasting consiste à convertir un objet de type enfant en un type parent, ce qui est toujours sûr. Le downcasting, en revanche, consiste à convertir un objet de type parent en un type enfant, ce qui peut être risqué et doit être fait explicitement.

3. Pourquoi l'instanciation d'une interface est-elle impossible ?

Les interfaces en Java ne peuvent pas être instanciées car elles ne contiennent que des déclarations de méthodes sans implémentation. Elles sont destinées à être implémentées par des classes concrètes qui fourniront les implémentations nécessaires.