Licence d'informatique
Programmation objet et Java

Questionnaire n°6


Question 1. On considère une classe Base qui a une méthode public void show(), et une sous-classe Der qui définit une méthode

public void doIt() {
  super.show();
}

(a) le préfixe super.ne peut être utilisé dans une méthode qui n'est pas un constructeur;
(b) le préfixe super.est inutile, sauf si Der a redéfini show().
(c) le préfixe super.est toujours requis pour appeler une méthode d'une superclasse.


Question 2. On considère la classe que voici:

class Test {
  int x;
  static void setX(int xx) { x = xx; }
}

(a) ne compile pas parce que la méthode setX() est static;
(b) compile mais lève une exception;
(c) la méthode setX() s'exécute normalement.


Question 3. On suppose définies deux classes d'exceptions

class MereException extends Exception {}
class FilleException extends MereException {}

et on considère le fragment de code suivant:

try{
    // le bloc
}
catch(MereException me, FilleException fe) {
  System.out.println("Une exception captée.");
}
(a) ne compile pas,
(b) n'imprime le message que si les deux exceptions sont levées dans le bloc,
(c) n'imprime le message que si les l'une des exceptions sont levées dans le bloc,
(d) rien de tout ca.


Question 4. On considère le fragment de code suivant:

public static void main(String[] args) {
  String texte = "Est-ce \"facile\" ? non, difficile!";
  StringTokenizer w = new StringTokenizer(texte , "\n\", ?");
  while (w.hasMoreTokens())
    System.out.print(w.nextToken() + "|");
  }
}
(a) ne compile pas parce que le constructeur StringTokenizer a 3 arguments;
(b) ne compile pas parce que texte est mal formé;
(c) le résultat est: Est-ce|facile|non|difficile!|
(d) le résultat est: Est-ce|"facile"|?|non|difficile!|
(e) le résultat est: Est-ce|"facile"?|non,|difficile!|
(e) rien de tout ça.


Question 5. On considère le programme que voici:

import java.io.*;

class FileDemo {
  public static void main(String[] args) {
    try {
      BufferedReader input;
      input = new BufferedReader(new FileReader("data.txt"));
      String ligne = null;
      int i = 0;
      try {
        while ((ligne = input.readLine()) != null)
        System.out.println(i+++ " " + ligne);
      }
      catch(IOException e) {
        System.out.println("Erreur de lecture");
      }
    }
    catch(FileNotFoundException e) {
      System.out.println("Fichier non trouvé");
    }
  }
}

(a) ne compile pas à cause des trois signe "+" consécutifs,
(b) ne compile pas parce que les noms des paramètres dans les catch  sont les mêmes,
(c) ne compile pas parce que FileReader lève une IOException
(d) affiche le contenu du fichier, précédé du numéro de ligne.


Question 6. Lesquelles des instructions suivantes sont autorisées:

(a) BufferedReader in = new BufferedReader(new FileReader("data.txt"));
(b) BufferedReader in = new BufferedReader(new File("data.txt"));
(c) BufferedReader in = new BufferedReader("data.txt");
(d) les trois sont autorisées;
(e) aucune n'est autorisée.


Question 7. On considère le programme que voici:

public static void main(String[] args) {
  List l = new ArrayList();
  l.add("Adam"); l.add("Eve"); l.add("Paul"); l.add("Alex"); l.add("Fred");
  Iterator i = l.iterator();
  while (i.hasNext()) {
    System.out.print(i.next()+" "); i.next();
  }
}

(a) ne compile pas.
(b) imprime Adam Paul Fred.
(c) imprime Adam Paul Fred puis lève une exception.
(d) imprime Eve Alex.
(e) rien de tout ça.


Question 8. On considère le programme que voici:

public static void main(String[] args) {
  Set l = new TreeSet();
  l.add("Fred"); l.add("Fred"); l.add("Adam"); l.add("Alex"); l.add("Eve"); l.add("Paul");
  Iterator i = l.iterator();
  while (i.hasNext()) {
    System.out.print(i.next()+" "); i.next();
  }
}
(a) ne compile pas.
(b) imprime Adam Paul Fred.
(c) imprime Adam Eve Paul puis lève une exception.
(d) rien de tout ça.


Question 9. On considère le comparateur que voici:

class OrdreBiz implements Comparator {
  public int compare(Object a, Object b) {
    int x = ((Integer) a).intValue();
    int y = ((Integer) b).intValue();
    boolean xpair = x == x/2*2;
    boolean ypair = y == y/2*2;
    return (xpair && ypair) ? y - x : (xpair) ? -1: x - y;
  }
}
(a) ne compile pas à cause de la syntaxe de xpair =
(b) ne compile pas à cause de la syntaxe de l'instruction conditionnelle
(c) les nombres pairs sont plus petits que les nombres impairs, et le nombres pairs sont ordonnés à l'envers,
(d) cet ordre est l'ordre usuel sur les entiers.
(e) rien de tout ça.


Question 10. On considère le programme que voici:

public static void main(String[] args) {
  Map tableNom = new TreeMap();
  tableNom.put("Dupont", "Alain"); tableNom.put("Durand", "Alex");
  tableNom.put("Dufour", "Alain"); tableNom.put("Duras", "Antoine");

  Map tablePrenom = new TreeMap();
  for (Iterator i = tableNom.entrySet().iterator(); i.hasNext();) {
    Map.Entry e = (Map.Entry) i.next();
    tablePrenom.put(e.getValue(), e.getKey());
  }
  System.out.println(tablePrenom);
}

(a) Lève une exception à l'exécution parce que Alain figure deux fois comme prénom
(b) Affiche {Dufour=Alain, Dupont=Alain, Durand=Alex, Duras=Antoine}
(c) Affiche {Alain=Dupont, Alex=Durand, Antoine=Duras}
(d) Affiche {Alain=Dufour, Alex=Durand, Antoine=Duras}
(e) rien de tout ça.