TP n°2

Exercice 0

1. Reprendre les classes du cours et les compiler. Ajouter les modificateurs public et private adéquat là où ils manquent.

2. Ajouter à chaque classe une méthode toString et tester chaque classe en créant deux objets différents et en les affichant.

Exercice 1

Écrire une class Chronometre donc le but est de mesurer une durée. On rappelle que System.nanoTime() donne un nombre de nanosecondes écoulée depuis une origine inconnue mais fixe. On ajoutera dans la classe :

1. un champ debut de type long initialisé à l’heure de création de l’objet
2. une méthode dureeMicro retournant le nombre de microsecondes (1µs = 1000ns) écoulées depuis l’initialisation du chronomètre
3. une méthode dureeMilli retournant le nombre de millisecondes (1ms = 1000000ns) écoulées depuis li’initialisation du chronomètre
4. une méthode reset qui remet à 0 le chronomètre.

Écrire un main de test (dans une classe à part) suivant :

class Prog {
  public static void main(String[] args) {
    Chronometre chronometre = new Chronometre();
    for(int i=1;i<=1000000;i=i+1) {
      if (i%1000==0) {
        System.out.println(i+" "+chronometre.dureeMicro());
      }
    }
    System.out.println(chronometre.dureeMilli());
    chronometre.reset();
    for(int i=1000000;i>=1;i=i-1) {
      if (i%1000==0) {
        System.out.println(i+" "+chronometre.dureeMicro());
      }
    }
    System.out.println(chronometre.dureeMilli());
  }
}

Exercice 2

Écrire une classe Attente dont le but est de prévenir quand un temps est dépassé, avec les fonctionnalités suivantes :

1. Quand on construit l’objet, on lui donne une durée.

2. La classe possède une methode tempsDepasse retourne true si le temps est dépassé depuis l’initialisation de l’objet et false sinon.

3. La classe possède une méthode attendFin qui bloque jusqu’à ce que le temps soit dépassé. Pour attendre un nombre donné de microsecondes, on utilisera la fonction suivante (penser à ajouter private ou public) :

    static void nanosleep(long nanoseconds) {
      try {
        java.util.concurrent.TimeUnit.NANOSECONDS.sleep(nanoseconds);
      }
      catch (java.lang.InterruptedException e) {
        throw new java.lang.AssertionError(e);
      }
    }
   

   Le sens du try, catch, java.util et java.lang seront compris à la fin du cours.

Exercice 3

Écrire une classe Casillo avec les méthodes suivantes :

1. chronometre qui retourne une nouvelle instance de Chronometre
2. attente qui retourne une nouvelle instance de Attente initialisée à une durée passée en paramètre de la méthode
3. attenteDefaut qui retourne une nouvelle instance de Attente initialisée à la valeur par défaut. Cette dernière est initialement de une seconde.
4. changeDefaut qui change le temps d’attente par défaut.

Exercice 4

On souhaite écrire une classe GestionnaireDeTache qui permet de demander d’être prévenu de la prochaine échéance.

1. Créer une classe Tache possédant une date limite d’accomplissement (un long indiquant un nombre de nanosecondes depuis l’origine fixe de System.nanoTime() et un description de type String.
2. Ajouter dans GestionnaireDeTache, des méthodes ou fonctions pour créer une instance de Tache en lui indiquant dans combien de temps la tâche doit être accomplie, en jours, en heures, en minutes ou en secondes.
3. Ajouter dans GestionnaireDeTache une méthode pour ajouter un objet Tache. Ces objets seront stockés dans un tableau et on supposera qu’il ne peut pas y avoir plus de 5000 tâches enregistrées.
4. Ajouter une méthode qui affiche toutes les tâches en cours, avec le temps qu’il reste pour les accomplir en heures (mais sous forme de flottants)
5. Ajouter dans la classe Tache des méthodes pour obtenir le temps restant en jours, en heures, en minutes et en secondes ainsi qu’une méthode qui indique si la date limite est dépassée
6. Ajouter une méthode à GestionnaireDeTache qui retire une tâche (parce qu’elle est annulée ou accomplie)
7. Ajouter une méthode à GestionnaireDeTache qui renvoie un tableau des tâches dont le délai est dépassé.
8. Ajouter une méthode à GestionnaireDeTache qui renvoie un tableau des tâches dont le délai est postérieur à celui d’une tâche passée en paraamètre.