Questionnaire n°5

---

Question 1. On considère une méthode d'objet:

public void show() {
  if (this == null)
    System.out.println("vide");
  else
    System.out.println("plein");
}

(a) la méthode ne compile pas;
(b) elle compile mais lève une NullPointerException;
(c) elle affiche vide si l'objet appelant est nul;
(d) elle n'affiche jamais vide.

---

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

class Test {
  public static void main(String[] args) {
    for (int i = 0; i < args.length; i++)
      System.out.print(args[i] + " ");
  }
}

class MainTest {
  public static void main(String[] args) {
    String[] a = {"Bonjour", "monde" };
    Test.main(a);
    System.out.println(".");
  }
}

(a) il ne compile pas parce que main est un mot réservé;
(b) il compile mais java MainTest lève une ClassNotFoundException;
(c) java MainTest  provoque l'affichage de Bonjour, monde .
(d) java MainTest provoque l'affichage d'un point seulement.

---

Question 3. Une classe Item a deux classes dérivées ItemA et ItemB. Une classe C possède les méthodes essai(ItemA a) et essai(ItemB b). Dans une méthode de la classe C, le code

Item b = new ItemB();
essai(b);

(a) ne compile pas,
(b) compile mais lève une exception,
(d) exécute la méthode essai(ItemB b).

---

Question 4. Une classe Animal a une sous-classe Chien et Chien a une sous-classe ChienDeChasse. On considère

Chien c = new ChienDeChasse();
boolean x = c instanceof Animal;
boolean y = c instanceof ChienDeChasse;

Qu'elles sont les valeurs de x et y ?

(a) true et true ;
(b) true  et false;
(c) false et true ;
(d) false et false.

---

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

interface Animal {
  void mord(Gardien g);
}
class Chien implements Animal {
  public void mord(Gardien g) {
    System.out.println(this + " ne mord pas " + g);
  }
}
class ChienDeChasse extends Chien {
  public void mord(Gardien g) {
    System.out.println(this + " mord " + g);
  }
}
class Gardien {
  void tatoue(Animal a) { a.mord(this); }
}

class TestZoo {
  public static void main(String[] args) {
    Gardien g = new Gardien();
    Animal a = new ChienDeChasse();
    g.tatoue(a);
  }
}

(a) ne compile pas, parce que le type de la variable a dans le main est une interface,
(b) compile mais lève un exception parce que Animalest une interface,
(c) affiche une ligne semblable à ChienDeChasse@273d3c mord Gardien@256a7c
(d) affiche une ligne semblable à Chien@720eeb ne mord pas Gardien@256a7c.

---

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

class WrapperTest {
  public static void main(String[] args) {
    double d = 0;
    String s = "chaine";
    Double enveloppe;
    try {
      try {
        enveloppe = Double.valueOf(s);
        d = enveloppe.doubleValue();
      }
      catch(NumberFormatException e) {
        System.out.println("Erreur");
       throw e;
      }
    }
    catch(NumberFormatException e) {
      System.out.println("Incorrect");
    }
  }
}

(a) ne compile pas parce que des blocs try imbriqués ne sont pas autorisés;
(b) le programme affiche Erreur et Incorrect;
(c) ne compile pas parce que throw doit créer un nouvel objet exception;
(d) ne compile pas parce que les types des deux catch sont les mêmes;
(e) affiche seulement Erreur
(f) affiche seulement Incorrect

---

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

class Question57 {
  public static void main(String[] args) {
    UneClasse ref1 = new UneClasse(5);
    UneClasse ref2 = new UneClasse(10);
    ref1.getAndShow(ref2);
  }
}
class UneClasse {
  private int x;
  UneClasse(int x) {
    this.x = x;
  }
  void getAndShow(UneClasse ref) {
    System.out.println(ref.x + " ");
  }
}

(a) ne compile pas.
(b) compile mais lève une exception.
(c) affiche 10.
(d) rien de tout ça.

---

Question 8. On veut calculer la taille du tableau passé en argument à la méthode:

public static void main(String[] args) {...}

Quelles sont les calculs valides?

(a) int num = args.length;
(b) int num = args.length - 1;
(c) int num = 0; while (args[num] != null) num++;
(d) int num = 0; while (!(args[num].equals(""))) num++;

---

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

class Base {
  public void print(String s) { System.out.println("Base: " + s); }
}
class Dérivée extends Base {
  public void print(String s) { System.out.println("Dérivée: " + s); }
  public void bis() {
    this.print("Un");
    super.print("Deux");
  }
  public static void main(String[] args) {
    Dérivée d = new Dérivée():
    d.bis();
  }
}

Qu'est-ce qui est affiché?

(a)  Dérivée: Un sur une ligne et Base: Deux sur la ligne suivante
(b)  Dérivée: Un sur une ligne et Dérivée: Deux sur la ligne suivante
(c)  Base: Un sur une ligne et Dérivée: Deux sur la ligne suivante
(d)  Base: Un sur une ligne et Base: Deux sur la ligne suivante
(e) rien de tout ça.

---

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

class Base {
  private int num = 10;
  public void print() { System.out.println(num); }
  public void setNum(int j) { num = j; }
}
class Dérivée extends Base {
  public void setNum(int j) { num = j + 10; }

  public static void main(String[] args) {
    Dérivée d = new Dérivée();
    d.setNum(20);
    d.print();
  }
}

(a) Ne compile pas
(b) Compile mais lève une exception à l'exécution
(c) Affiche 10
(d) Affiche 20
(e) Affiche 30.