Université de Nice Sophia-Antipolis

DU IG - Introduction à la programmation objet - 2009-12

Examen du 1er décembre 2009

Durée : 2h.

Seuls documents autorisés : photocopies des transparents distribués en cours ; les énoncés et corrections des TP et des contrôles sont interdits. Éteignez les téléphones portables.

Important : la présentation et la lisibilité du code compteront dans la note finale. Vous êtes autorisé à écrire le code (et seulement le code) avec un crayon à papier si c'est parfaitement lisible (pas de crayon trop clair).

Ajoutez des commentaires quand vous pensez que ça peut être utile au correcteur. Ne mettez pas de commentaires évidents qui n'ajoutent rien à votre code.

Respectez le découpage en questions et l'ordre des questions. Les numéros des questions devront apparaître clairement sur votre feuille.

Exercice 1 (9 points)

Dans la paquetage fr.unice.du vous allez écrire une classe TrierTirages dont la méthode main tire 1000 nombres au hasard, compris entre 1 et 100, et qui affiche le nombre le plus tiré avec son nombre de tirages, sous la forme "58 : 42 tirages" si le nombre 52 a été tiré 18 fois. Pour simplifier vous supposerez qu'il n'y a pas d'ex aequo. Pour faciliter la vérification, la méthode main affiche à la fin le tableau de tous les tirages, en utilisant une méthode de la classe java.util.Arrays.

Pour cela vous écrirez une méthode tirage qui tire un nombre entier au hasard compris (bornes comprises) entre 1 et n (n est un paramètre de la méthode). Cette méthode utilisera la méthode random de la classe java.lang.Math dont voici la javadoc (simplifiée) :

public static double random()
Returns a double value with a positive sign, greater than or equal to 0.0 and less than 1.0. 
Returned values are chosen pseudorandomly with (approximately) uniform distribution from that range.
Returns: a pseudorandom double greater than or equal to 0.0 and less than 1.

Vous écrirez aussi une méthode accumulationTirages qui tire p (paramètre de la méthode) nombres compris entre 1 et n (n, paramètre de la méthode) et qui renvoie un tableau contenant le nombre de fois qu'un nombre a été tiré. Par exemple, si t est le tableau renvoyé, t[8] contient le nombre de fois que le nombre 8 a été tiré. Remarque : l'élément du tableau d'indice 0 n'est pas utilisé.

Correction:

package fr.unice.du;


import java.util.Arrays;


public class TrierTirages {
  
  private static int tirage(int n) {
    return (int)(Math.random() * n) + 1;
  }
  
  /**
   * Tire au hasard des nombres compris entre 1 une borne maximum et conserve les tirages.
   * @param p le nombre de tirages
   * @param n borne maximum pour les nombres tirés au hasard
   * @return un tableau de longueur p + 1 dont le ième élément contient le nombre de fois
   * que i a été tiré (l'élément d'indice 0 n'est pas utilisé et contient 0).
   */
  private static int[] accumulationTirages(int p, int n) {
    // n + 1 car la case d'indice 0 n'est pas utilisée.
    int[] resultats = new int[n + 1];
    for (int i = 0; i < p; i++) {
      int nbTire = tirage(n);
      resultats[nbTire]++; // ou resultats[nbTire] = resultats[nbTire] + 1;
    }
    return resultats;
  }

  public static void main(String[] args) {
    int[] tirages = accumulationTirages(1000, 100);
    // Recherche le plus grand élément du tableau
    int max = -1;
    int nbLePlusTire = -1;
    for (int i = 0; i < tirages.length; i++) {
      if (tirages[i] > max) {
        max = tirages[i];
        nbLePlusTire = i;
      }
    }
    // Affichage du résultat
    System.out.println(nbLePlusTire + " : " + max + " tirages");
    // Pour vérification :
    System.out.println(Arrays.toString(tirages));
  }
}

Exercice 2 (7 points)

Voici une classe Livre :

public class Livre {
  private String titre;
  private int nbPages;


  public Livre(String titre, int nbPages) {
    this.titre = titre;
    this.nbPages = nbPages;
  }
  public String getTitre() {
    return titre;
  } 
  public void getNbPages() {
    return nbPages;
  }
}

La méthode main d'une classe Main remplit un tableau de livres :

public static void main(String[] args) {
  Livre[] livres = new Livre[100];

livres[0] = new Livre("Les misérables", 508); livres[1] = new Livre("Le bonheur", 112); // Les 98 autres livres sont ajoutés au tableau ....
  1. Ecrivez une méthode de classe plusGrosLivre de la classe Main qui prend en paramètre un tableau de livres (supposé complètement rempli) et qui renvoie le plus gros livre (celui qui a le plus de pages).
  2. Ecrivez l'appel et l'utilisation cette méthode à la fin de la méthode main pour afficher le titre du plus gros livre du tableau livres. La méthode main affichera une ligne du type "Le livre Twilight a 1200 pages" si c'est ce livre qui a le plus de pages.

Correction :

package du.exam2009;

import java.util.Arrays;

public class Main {
  
  /**
   * Tire au hasard un nombre entre min et max (compris)
   * @param min
   * @param max
   * @return le nombre tiré au hasard
   */
  private static int tirage(int min, int max) {
    return (int)(Math.random() * (max - min + 1)) + min;
  }

  public static void main(String[] args) {
    Livre[] livres = new Livre[100];
    // Crée les 100 (pseudo) livres
    for (int i = 0; i < 100; i++) {
      livres[i] = new Livre("Titre" + i, tirage(80, 1200));
    }
    Livre livre = plusGrosLivre(livres);
    System.out.println("Le livre " + livre.getTitre() + " a " + livre.getNbPages() + " pages");
    // Pour vérification
    System.out.println(Arrays.toString(livres));    
  }
  
  private static Livre plusGrosLivre(Livre[] livres) {
    Livre livre = null;
    int max = 0;
    for (int i = 0; i < livres.length; i++) {
      Livre l = livres[i];
      if (l.getNbPages() > max) {
        max = l.getNbPages();
        livre = l;
      }
    }
    return livre;
  }
}

Exercice 3 (4 points)

  1. A quoi servent les paquetages ?
    Ils permettent de distinguer des classes qui ont le même nom mais qui ont été écrites par des personnes différentes et pour des usages différents. Par exemple, pour distinguer 2 classes Liste, l'une désignant la structure de liste d'attente et l'autre désignant une liste déroulante dans une interface graphique. Ils permettent de ranger les classes par thèmes ou par un critère quelconque. Les paquetages permettent aussi d'ajouter un autre degré d'encapsulation : les classes d'un même paquetage ont mutuellement accès à leurs membres qui n'ont pas d'attribut d'accès (ni public, ni private).
  2. Quel est l'intérêt de mettre "private" les variables d'instance d'une classe.
    Ces variables sont ainsi protégées contre les autres classes qui voudraient y affecter des valeurs interdites. Si ces variables peuvent recevoir des valeurs de l'extérieur de la classe, il faudra passer par un modificateur qui pourra contrôler les valeurs qu'on voudra leur affecter. Un autre intérêt très important, mais pas expliqué dans le cours (donc pas pris en compte pour la notation), est de cacher l'implémentation de la classe. Ce dernier aspect sera vu dans le cours de L3.