src/main/java/fr/univamu/Main.java

-package fr.univamu;
-
-public class Main {
-
-}
\ No newline at end of file

src/main/java/fr/univamu/progav/Main.java

 package fr.univamu.progav;
 
+import fr.univamu.progav.td2.DebuggerTutorial;
+
 public class Main {
 
   public static void main(String[] args) {
-
+    new DebuggerTutorial().exoDebug(); // TD2
   }
 }

src/main/java/fr/univamu/progav/td1/ExercicesConditionnelle.java

@@ -36,13 +36,13 @@ public class ExercicesConditionnelle {
   // bénéficient d’un tarif réduit à 5 euros. Enfin, les personnes ayant un
   // abonnement annuel ne paient rien.
 
-  public interface Costumer {
+  public interface Customer {
     int age();
     boolean isUnemployed();
     boolean hasAnnualSubscription();
   }
 
-  public static double getPrice(Costumer costumer) {
+  public static double getPrice(Customer customer) {
     return 0;
   }
 

src/main/java/fr/univamu/progav/td2/ASimpleLoop.java

+package fr.univamu.progav.td2;
+
+public class ASimpleLoop {
+
+  public static double nonTerminatingSum(int n) {
+    double sum = 0;
+    for (double i = 0; i != n; i = i + 0.1) {
+      sum = sum + i ;
+    }
+    return sum;
+  }
+
+}

src/main/java/fr/univamu/progav/td2/BackPackSolver.java

+package fr.univamu.progav.td2;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BackPackSolver {
+
+
+
+  private final List<Item> allItems;
+  private final List<Item> currentBackpack = new ArrayList<>();
+  private final int availableVolume;
+
+  public BackPackSolver(List<Item> allItems, int availableVolume) {
+    this.allItems = allItems;
+    this.availableVolume = availableVolume;
+  }
+
+
+  public List<Item> findBestValueBackpack(int nextItemIndex) {
+    if (nextItemIndex >= allItems.size()) {
+      return new ArrayList<>(currentBackpack);
+    }
+    List<Item> backpack1 = findBestValueBackpack(nextItemIndex+1);
+    int currentVolume = sumVolumes(currentBackpack);
+    if (currentVolume + allItems.get(nextItemIndex).volume > availableVolume) {
+      return backpack1;
+    }
+    currentBackpack.add(allItems.get(nextItemIndex));
+    List<Item> backpack2 = findBestValueBackpack(nextItemIndex+1);
+    currentBackpack.removeLast();
+    return selectBestBackpack(backpack1, backpack2);
+  }
+
+
+
+  private List<Item> selectBestBackpack(List<Item> backpack1, List<Item> backpack2) {
+    int value1 = sumValues(backpack1);
+    int value2 = sumValues(backpack2);
+    return (value1 >= value2)? backpack1 : backpack2;
+  }
+
+  public record Item(String name,int volume, int value) {
+    @Override
+    public String toString() {
+      return name + " (Volume=" + volume + ", value=" + value + ")";
+    }
+  }
+
+  private static int sumValues(List<Item> backpack1) {
+    return backpack1.stream().mapToInt(Item::value).sum();
+  }
+
+  private int sumVolumes(List<Item> backpack) {
+    return backpack.stream().mapToInt(Item::volume).sum();
+  }
+
+}

src/main/java/fr/univamu/progav/td2/DebuggerTutorial.java

+package fr.univamu.progav.td2;
+
+public class DebuggerTutorial {
+
+  private int x = 2;
+  private String text = "an instance variable of a DebuggerTutorial instance";
+
+  public void exoDebug() {
+    double x = 1;
+    f();
+    A a = new A();
+    a.g();
+    for (int i = 0; i < 100000; i++) {
+      String s = "Reprendre l'exécution pour passer la boucle";
+    }
+    String r = "Si vous voyez ceci dans le débugger, c'est GAGNÉ";
+    System.out.println("The end.");
+  }
+
+  public void f() {
+    System.out.println("In method f.");
+    double x = 0;
+    String bad = "Si vous voyez ceci dans le débugger, c'est PERDU.";
+    double y = 0;
+  }
+
+  class A {
+    private final int x = 42;
+
+    public void g() {
+      String bad = "Si vous voyez ceci dans le débugger, c'est PERDU.";
+      System.out.println("In method g.");
+    }
+  }
+
+
+}

src/main/java/fr/univamu/progav/td2/GuessingGame.java

+package fr.univamu.progav.td2;
+
+public class GuessingGame {
+
+  public static int solve(int mystery) {
+    return new GuessingGame(mystery).nbAttempts();
+  }
+
+  public static final int LOWER_BOUND = 1;
+  public static final int UPPER_BOUND = 1000;
+
+  private final int mystery;
+  private int attempts = 0;
+
+  public GuessingGame(int mystery) {
+    this.mystery = mystery;
+    guess(LOWER_BOUND, UPPER_BOUND);
+  }
+
+  private int nbAttempts() {
+    return attempts;
+  }
+
+  private void guess(int lowerBound, int upperBound) {
+    this.attempts++;
+    if (lowerBound == upperBound) {
+      return;
+    }
+    int middle = (upperBound + lowerBound) / 2;
+    if (middle == mystery) {
+      return;
+    }
+    if (middle < mystery) {
+      guess(middle,upperBound);
+    } else {
+      guess(lowerBound,middle-1);
+    }
+
+  }
+
+}

src/main/java/fr/univamu/progav/td2/People.java

+package fr.univamu.progav.td2;
+
+import java.util.List;
+
+public class People {
+
+  private final String name;
+  private final int age;
+
+  public People(String name, int age) {
+    this.name = name;
+    this.age = age;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public int getAge() {
+    return age;
+  }
+
+  /** Decides whether the list contains a 25-year-old "Charlie"
+   * @param peopleList
+   * @return true if a 25-year-old charlie is in the list
+   */
+  public static int whereIsCharlie(List<People> peopleList) {
+    People charlie = new People("Charlie", 25);
+    int count = 0;
+    for (People p : peopleList) {
+      if (p == charlie) {
+        return  count;
+      }
+      count++;
+    }
+    return -1; // Charlie is not here.
+  }
+
+
+  @Override
+  public String toString() {
+    return this.name;
+  }
+}

src/main/java/fr/univamu/progav/td2/Ratio.java

+package fr.univamu.progav.td2;
+
+public class Ratio {
+
+  private final int num;
+  private final int denom;
+
+  private Ratio(int num, int denom) {
+    this.num = num;
+    this.denom = denom;
+  }
+
+  /** Builds a ratio, given its numerator and denominator
+   * @param num the numerator of the ratio
+   * @param denom the denominator of the ratio
+   * @return a reduced ratio equals to num/denom, represented in reduced form.
+   */
+  public static Ratio of(int num, int denom) {
+    int d = gcd(denom, num);
+    return new Ratio(num / d, denom /d );
+  }
+
+  // UnsafeOf is used in test, to build a ratio without reducing it,
+  // and must be used with already reduced numerator and denominator.
+  protected static Ratio unsafeOf(int num, int denom) {
+    return new Ratio(num, denom);
+  }
+
+  // Euclid's algorithm
+  public static int gcd(int a, int b) {
+    return a == 0 || b == 0? a + b:
+           gcd(b, a % b);
+  }
+
+
+  public Ratio plus(Ratio r) {
+    return of(this.num * r.denom + this.denom * r.num, this.denom * r.denom);
+  }
+
+
+  @Override
+  public boolean equals(Object obj) {
+    if (!(obj instanceof Ratio r)) {
+      return false;
+    }
+    return r.num == this.num && r.denom == this.denom;
+  }
+
+  @Override
+  public String toString() {
+    double value = this.num / (double) this.denom;
+    return String.valueOf(value);
+  }
+}

src/main/java/fr/univamu/progav/td2/TD2.md

+Introduction
+============
+
+Dans les exercices suivants, chaque petit programme comporte une 
+erreur, qui 
+apparait lors du test. L'objectif est d'apprendre à utiliser le débugger 
+pour Java d'IntelliJ pour trouver la cause de l'erreur, et la corriger.
+
+La tâche Gradle permet de lancer les tests, mais on préfèrera cette fois 
+lancer uniquement le test de l'exercice en cours. Pour cela, ouvrir le 
+fichier contenant le test, trouver la méthode de test, et dans la marge 
+`clic gauche` sur l'icône de lancement ![run](../../../../../resources/run.png),
+et choisir l'option *debug* ![debug](../../../../../resources/debug.png).
+
+Pour arrêter le débugger à une instruction du programme, il faut placer des 
+*breakpoints* ![breakpoint](../../../../../resources/breakpoint.png). Il suffit 
+pour cela d'un `clic gauche` dans la marge du programme, sur le numéro de 
+ligne. Un `clic droit` permet de le paramétrer si nécessaire, et un deuxième 
+`clic gauche` le fait disparaître.
+
+Lorsque le programme s'exécute, il s'interrompt automatiquement aux 
+breakpoints, et affiche l'état de la pile.
+
+![Panneau de débuggage](../../../../../resources/debug-panel.png)
+
+Dans la partie gauche se trouve la liste des *frames*, c'est-à-dire des 
+niveaux ou couches de la pile, la plus récente en haut. Attention, lancer un 
+test demande un grand nombre d'appels de méthode avant d'arriver à la 
+méthode de test, donc la plupart des *frames* ne sont pas pertinents, seuls 
+les frames les plus hauts, pour lesquels on reconnaît les méthodes du projet,
+nous intéressent.
+
+La partie droite affiche le contenu du frame courant, en commençant par la 
+valeur de `this` (si la méthode n'est pas statique), puis toutes les 
+variables et leurs valeurs. Les tableaux et les objets peuvent être 
+inspectés en dépliant les arborescences.
+
+La barre du haut contient les actions réalisables, dont voici les plus 
+importantes.
+
+![Relancer](../../../../../resources/rerun.png) relance le test depuis le 
+début, toujours en mode *debug*.
+
+![Arrêter](../../../../../resources/stop.png) arrête l'évaluation du 
+programme immédiatement, et ferme le débuggeur.
+
+![Reprendre](../../../../../resources/resume.png) reprend l'évaluation, 
+jusqu'au prochain *breakpoint* ou la fin normale de l'exécution du programme.
+
+![Passer](../../../../../resources/step-over.png) passe à l'instruction 
+suivante, en ignorant tout appel de méthodes dans l'instruction en cours.
+
+![Entrer](../../../../../resources/step-into.png) passe à la première 
+instruction d'une méthode appelée dans l'instruction en cours. En cas de 
+choix entre plusieurs méthodes (ou constructeurs), il faut cliquer sur celle 
+qui nous intéresse. Il est conseillé de ne pas entrer dans les méthodes ne 
+faisant pas partie du projet.
+
+![Sortir](../../../../../resources/step-out.png) reprend l'exécution jusqu'à 
+terminer la méthode actuellement en cours, et s'interrompt à l'instruction 
+ayant appelé la méthode.
+
+Ces actions permettent d'exécuter le programme pas-à-pas, plus ou moins 
+finement, en inspectant les valeurs des variables. 
+
+
+Exercice 1
+==========
+
+Ce petit exercice vous permet de prendre en main le débugger d'IntelliJ.
+
+- Vérifier que la méthode exécutable `main` de la classe `Main` (fichier `fr.
+univamu.progav.Main.java`) appelle bien la méthode `exoDebug` d'une instance de 
+  la classe `DebuggerTutorial` (sinon appeler l'enseignant).
+- Exécuter le programme (tâche gradle run). Le programme doit afficher :
+```
+In method f.
+In method g.
+The end.
+```
+- Placer un *breakpoint* sur la première 
+  ligne de la méthode `exoDebug` (comment ? lire ci-dessus). Relancer le 
+  programme 
+  en mode debug (bouton ![debug](../../../../../resources/debug.png) en haut 
+  à droite). À l'issue de la compilation, vous obtiendrez l'ouverture de la 
+  vue du debugger.
+- Inspecter l'objet `this`. Quelles sont ses propriétés et leurs valeurs ? 
+  Ceci correspond-il bien au programme écrit ?
+- Avancer l'exécution d'une instruction 
+  ![Passer](../../../../../resources/step-over.png). Quel est l'effet de 
+  l'instruction ? 
+- Entrer dans l'exécution de la méthode `f`
+  ![Entrer](../../../../../resources/step-into.png). Combien la pile 
+  a-t-elle de couches ? Quelles sont les valeurs de la variable `x` dans les 
+  différentes couches de la pile ?
+- Ressortir de la méthode `f`
+  ![Sortir](../../../../../resources/step-out.png). Exécuter l'instruction 
+  créant une instance de la classe `A` et vérifier son effet sur la mémoire. 
+  Quelle est la référence du nouvel objet ?
+- Sauter l'appel de la méthode `g`
+  ![Passer](../../../../../resources/step-over.png).
+- Ajouter un breakpoint après la boucle, puis reprendre l'exécution du 
+  programme ![Reprendre](../../../../../resources/resume.png).
+- Continuer jusqu'à voir le message de victoire dans le débugger. Sinon 
+  recommencer.
+
+
+Exercice 2
+==========
+
+Dans la classe `People`, la méthode `whereIsCharlie` devrait retourner la 
+position de Charlie, 25 ans, dans la liste. Utiliser le test et le débuggeur 
+pour trouver l'erreur.
+
+Exercice 3
+==========
+
+Dans la classe `ASimpleLoop`, la méthode `nonTerminatingSum` fait un calcul, 
+qui ne termine pas. Utiliser le test et le débuggeur, pour comprendre 
+pourquoi elle ne termine pas. Corriger ensuite la méthode pour que le calcul 
+s'arrête,
+
+Exercice 4
+==========
+
+Dans la classe `Ratio`, représentant les nombres rationnels, l'addition ne 
+semble pas produire le bon résultat. Pourtant, nous avons pris soin de bien 
+réduire les fractions en calculant le plus grand commun diviseur avec 
+l'algorithme d'Euclide, et de forcer cette réduction dans la méthode 
+statique `of` que nous utilisons pour construire les fractions. Pour être 
+sûr de bien tester, nous avons aussi ajouter une méthode `unsafeOf`, qui 
+ignore l'étape de réduction : ainsi les valeurs attendues dans les tests 
+sont certainement bien définies (nous les avons réduites nous-mêmes). Enfin, 
+la méthode de test d'égalité profite de la forme réduite : il suffit de 
+tester l'égalité des numérateurs et des dénominateurs. Utiliser la méthode 
+de test et le débuggeur pour trouver l'erreur et la corriger. 
+
+
+Exercice 5
+==========
+
+La classe `GuessingGame` reprend la stratégie optimale pour le jeu 
+consistant à trouver un entier d'un intervalle (par exemple entre 1 et 1000),
+en tentant des valeurs, et en obtenant pour chaque mauvaise réponse une 
+indication "plus petit" ou "plus grand". Bien sûr, il s'agit de faire une 
+recherche dichotomique. Ici, une erreur a été faite, et la dichotomie ne 
+termine pas toujours. Il va d'abord falloir trouver une valeur mystère pour 
+laquelle l'algorithme boucle infiniment (provoquant un dépassement de pile). 
+Ensuite, en utilisant le débuggeur et en partant avec cette valeur, il sera 
+possible de repérer la raison pour laquelle l'algorithme boucle ainsi. 
+Utiliser donc une fois de plus le débugger pour trouver et corriger l'erreur.
\ No newline at end of file

src/main/java/fr/univamu/progav/td3/ExoArray.java

+package fr.univamu.progav.td3;
+
+public class ExoArray {
+
+  /** Initialise un tableau d'entiers, la cellule d'indice \(i\) contient l'entier \(i\), sauf une
+   * cellule sur trois depuis l'indice 1, qui contiennent \(-i\). Ainsi le tableau commence par
+   * <code>{0,-1,2,3,-4,5,6,-7,...}</code>.
+   * @param size la longueur souhaitée du tableau
+   * @return le tableau d'entiers
+   */
+  public static int[] initArray(int size) {
+    // TODO
+    return null;
+  }
+
+  /** Calcule la somme des entiers en position paire dans un tableau.
+   * Par exemple pour <code>{1,3,2,4}</code> le résultat est \(3 = 1 + 2\).
+   * @param array le tableau dont on somme les entiers en position paire.
+   * @return la somme des entiers en position paire.
+   */
+  public static int sumEvenPositions(int[] array) {
+    // TODO
+    return 0;
+  }
+
+  /** Décale tous les éléments du tableau "vers la gauche", sauf l'élément d'indice 0 qui est
+   * replacé en fin de tableau. Par exemple pour <code>{1,4,2,3}</code>, le tableau devient
+   * <code>{4,2,3,1}</code>.
+   * @param array le tableau à modifier.
+   */
+  public static void shiftToLeft(int[] array) {
+    // TODO
+  }
+}

src/main/java/fr/univamu/progav/td3/ExoList.java

+package fr.univamu.progav.td3;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ExoList {
+
+  /** Initialise une liste d'entiers consécutifs depuis 0, par exemple <code>0,1,2,3,4</code>.
+   * @param size la longueur souhaitée de la liste.
+   * @return la liste ainsi initialisée.
+   */
+  public static List<Integer> initList(int size) {
+    // TODO
+    return null;
+  }
+
+  /** Ajoute 1 à chaque entier d'une liste.
+   * @param values la liste des entiers à incrémenter.
+   */
+  public static void addOneEverywhere(List<Integer> values) {
+    // TODO
+  }
+
+  /** Duplique chaque élément de la liste, en fin de liste, par exemple la liste <code>1,2,
+   * 3</code> devient <code>1,2,3,1,2,3</code>.
+   * @param values la liste à dupliquer.
+   */
+  public static void duplicate(List<Integer> values) {
+    // TODO
+  }
+}

src/main/java/fr/univamu/progav/td3/ExoMap.java

+package fr.univamu.progav.td3;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Une classe permettant de compter dans un texte, pour chaque mot, combien de fois il apparait.
+ */
+public class ExoMap {
+
+  // TODO initialisation à une table d'association vide
+  private final Map<String,Integer> counters = null;
+
+  /** Augmente le compte d'un mot.
+   * @param word le mot à compter.
+   */
+  public void count(String word) {
+    // TODO
+  }
+
+  /** Compte tous les mots d'une liste.
+   * @param words une liste de mots à compter.
+   */
+  public void count(List<String> words) {
+    // TODO
+  }
+
+  /** Retourne le nombre d'occurences comptées d'un mot.
+   * @param word un mot.
+   * @return le nombre d'occurences de ce mot.
+   */
+  public int countOf(String word) {
+    // TODO
+    return 0;
+  }
+
+}
+
+
+

src/main/java/fr/univamu/progav/td3/ExoQueue.java

+package fr.univamu.progav.td3;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+
+/**
+ *  Une classe permettant d'évaluer des expressions arithmétiques entières en notation polonaise
+ *  inverse, comme <em>3 5 2 * 1 + -4 7 + + *</em>. L'évaluation d'une telle expression se fait à
+ *  l'aide d'une pile, et en lisant l'expression de gauche à droite :
+ *  <ul>
+ *    <li>3 : on empile 3, la pile est \([3]\)</li>
+ *    <li>5 : on empile 5, la pile est \([3,5]\)</li>
+ *    <li>2 : on empile 2, la pile est \([3,5,2]\)</li>
+ *    <li>* : on remplace les deux éléments supérieurs par leur produit, la pile est \([3,10]\) </li>
+ *    <li>1 : on empile 1, la pile est  \([3,10,1]\)</li>
+ *    <li>+ : on remplace les deux éléments supérieurs par leur somme, la pile est  \([3,11]\)</li>
+ *    <li>-4 : on empile -4, la pile est  \([3,11,-4]\)</li>
+ *    <li>7 : on empile 7, la pile est  \([3,11,-4,7]\)</li>
+ *    <li>+ : on remplace les deux éléments supérieurs par leur somme, la pile est  \([3,11,3]\) </li>
+ *    <li>+ : on remplace les deux éléments supérieurs par leur somme, la pile est  \([3,14]\)</li>
+ *    <li>* : on remplace les deux éléments supérieurs par leur produit, la pile est \([42]\)
+ *    </li>
+ *  </ul>
+ *  Un des avantages de cette notation est l'absence de parenthèses, qui sont inutiles.
+ */
+public class ExoQueue {
+
+  // TODO initialisée avec une pile vide
+  private final Deque<Integer> intStack =null;
+
+
+  /** Insère une valeur en haut de la pile.
+   * @param value la valeur à insérer.
+   */
+  public void addValue(int value) {
+    // TODO
+    intStack.offerLast(value);
+  }
+
+  /**
+   * Réalise l'addition des deux premiers éléments de la pile.
+   */
+  public void performAddition() {
+    //TODO
+  }
+
+  /**
+   * Réalise la multiplication des deux premiers éléments de la pile.
+   */
+  public void performMultiplication() {
+    // TODO
+  }
+
+  /**
+   * @return le nombre de valeurs dans la pile
+   */
+  public int nbRemainingValues() {
+    // TODO
+    return 0;
+  }
+
+  /**
+   * @return la valeur en haut de la pile (<code>null</code> si la pile est vide)
+   */
+  public int topValue() {
+    // TODO
+    return 0;
+  }
+
+}

src/main/java/fr/univamu/progav/td3/ExoSet.java

+package fr.univamu.progav.td3;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class ExoSet {
+
+  /** Construit l'ensemble des éléments d'une liste (les éléments redondants disparaissent).
+   * @param list la liste des éléments qui seront dans l'ensemble.
+   * @return l'ensemble ainsi construit.
+   */
+  public static Set<Integer> fromList(List<Integer> list) {
+    // TODO
+    return null;
+  }
+
+  /** Construit la liste des éléments de l'union de deux ensembles. Chaque élément doit
+   * apparaître au plus une fois.
+   * @param set1 le premier ensemble.
+   * @param set2 le deuxième ensemble.
+   * @return une liste union des deux ensembles.
+   */
+  public static List<Integer> unionToList(Set<Integer> set1, Set<Integer> set2) {
+    // TODO
+    return null;
+  }
+
+}

src/main/java/fr/univamu/progav/td3/TD3.md

+Exercice 1
+==========
+
+Un tableau est une structure indicée de taille fixe, contenant des valeurs 
+d'un même type.
+
+Compléter les méthodes de la classe `ExoArray`, jusqu'à validation des tests.
+
+Exercice 2
+==========
+
+Une liste est une collection indicée de taille variable, contenant des 
+valeurs d'un même type.
+
+Compléter les méthodes de la classe `ExoList`, jusqu'à validation des tests.
+
+Exercice 3
+==========
+
+Une file est une collection de valeurs de même type, organisées en séquences,
+avec des opérations d'insertion et de suppression à ses extrémités.
+
+Compléter les méthodes de la classe `ExoQueue`, jusqu'à validation des tests.
+Cette classe permet l'évaluation d'expressions arithmétiques en notation 
+polonaise inversée.
+
+Exercice 4
+==========
+
+Un ensemble est une collection de valeur d'un même type, chaque valeur y est 
+unique, et optimisée pour réaliser les opération d'insertion, suppression et 
+test d'appartenance. 
+
+Compléter les méthodes de la classe `ExoSet`, jusqu'à validation des tests.
+
+Exercice 5
+==========
+
+Une table d'association est une collection de clés d'un même type, chaque 
+clé étant unique, et associant à chaque clé une valeur. Toutes les valeurs 
+sont du même type. Une table d'association est optimisée pour 
+insérer ou supprimer efficacement les clés, et récupérer ou modifier la 
+valeur associée d'une clé.
+
+Compléter les méthodes de la classe `ExoMap`, jusqu'à validation des tests.
+Cette classe permet de compter le nombre d'occurrences de chaque mot dans une 
+liste de mots.
+
+
+

src/main/java/fr/univamu/progav/td4/TD4.md

+Cette semaine, les exercices consistent en créer des énumérations, 
+enregistrements et interfaces scellés. Nous n'écrirons pas de méthode, donc 
+il n'y a pas de test associé, ni de classes fournies. Un fois l'exercice 
+fini, demandez à votre enseignant d'évaluer votre solution.
+
+Introduction
+============
+
+Un atelier de céramistes d'Aubagne produit différents objets en terre cuite, et 
+nous demande de réaliser une application pour gérer ses commandes. Pour cela nous 
+devons représenter chaque objet pouvant être fabriqué. Il s'agit
+1. d'escudelles, caractérisées par un diamètre (en centimètres);
+2. de mazettes, existants en trois tailles (taille café, taille thé ou 
+   taille chocolat);
+3. de toupins, définis par une contenance en litres;
+4. de poumié, avec un nombre arbitraire de pommes (généralement 3 ou 6).
+
+De plus, chaque objet peut être fabriqué avec une couleur au choix, parmi :
+1. Corail
+2. Olive
+3. Jaune de cobalt
+4. Indigo
+5. Chartreuse
+6. Blanc lunaire
+7. Céruléen
+
+
+Exercice 1
+==========
+
+Créer un fichier `Color.java` et y définir une énumération pour représenter 
+toutes les couleurs disponibles.
+
+Exercice 2
+==========
+
+Définir une énumération pour les tailles des mazettes, dans un fichier 
+`Mazette.java`.
+
+Exercice 3
+==========
+
+Définir dans un fichier `Mazette.java`, un enregistrement pour représenter 
+les mazettes.
+
+Exercice 4
+==========
+
+Procéder de même pour définir des enregistrements pour représenter les 
+escudelles, les toupins et les poumiés.
+
+Exercice 5
+==========
+
+Créer une interface scellée `Product`, dans un fichier du même nom. Un 
+produit peut-être l'un des quatre proposés. Assurez-vous que chaque produit 
+possède bien une couleur.
+
+
+

src/main/java/fr/univamu/progav/td5/Blow.java

+package fr.univamu.progav.td5;
+
+public record Blow(int physicalDamage, int magicalDamage) {
+}

src/main/java/fr/univamu/progav/td5/Character.java

+package fr.univamu.progav.td5;
+
+public abstract class Character {
+
+  // TODO add health points
+
+  public boolean isAlive() {
+    // TODO
+    return false;
+  }
+
+  protected int getHealth() {
+    // TODO
+    return 0;
+  }
+  protected void reduceHealth(int amount) {
+    // TODO
+  }
+  protected void setHealth(int health) {
+    // TODO
+  }
+
+  public abstract Blow attack();
+
+  public abstract void defend(Blow blow);
+
+  public abstract void specialAction();
+
+}

src/main/java/fr/univamu/progav/td5/TD5.md

+Dans cet exercice, nous implémentons le comportement de trois personnages, le 
+guerrier, le mage et le prêtre, dans un jeu de rôle. Chacun peut donner et 
+recevoir des coups, a des points de vie et meurt lorsque ses points de vie 
+deviennent négatifs. Par contre, ils réagissent différemment aux coups, ont des 
+attaques différentes et ont chacun une action spéciale spécifique.
+
+Les coups sont décrits par la classe `Blow`, chaque coup ayant une 
+composante *dommage physique* et une composante *dommage magique*.
+Chaque point de dommage, physique ou magique, fait baisser d'un point la vie 
+du personnage recevant le coup.
+
+Le guerrier
+-----------
+
+- Ses attaques sont physiques : 3 dommages physiques et 0 dommage magique.
+- Il est costaud : il ne subit que la moitié des dommages physiques des 
+  coups qu'il reçoit.
+- Il peut entrer en rage avec son action spéciale. Sa rage lui permet de 
+  frapper deux fois plus fort pendant 3 attaques (6 dommages physiques).
+- Après 3 attaques, il perd sa rage.
+- S'il reçoit un coup provoquant une perte d'au moins 5 points de vie 
+  pendant sa rage, sa rage dure une attaque supplémentaire.
+
+Le mage
+-------
+
+- Ses attaques sont magiques : 4 dommages magiques et 0 dommage physique.
+- Il absorbe la magie : s'il reçoit un coup, il ne perd pas de vie à cause 
+  des dommages magiques, au contraire, la moitié des dommages magiques du 
+  coup s'annule avec les dommages physiques (par exemple, pour 5 dommages 
+  physiques et 3 magiques, il ne perd que 5 - (3/2) = 4 points de vie).
+- L'absorption de magie ne lui permet pas de gagner des points de vie 
+  (seulement de réduire les dommages physiques).
+- Son action spéciale consiste à invoquer un bouclier magique, qui absorbe 
+  les dommages physiques, jusqu'à 8 points. Le bouclier disparait une fois 
+  qu'il a absorbé 8 points au total (par exemple après deux attaques faisant 
+  5 dommages physiques chacune, il laissera passer 2 dommages physiques lors 
+  de la deuxième attaque).
+- Le bouclier est appliqué avant la règle de l'absorption des dommages magiques.
+
+
+Le prêtre
+---------
+
+- Ses attaques combinent force (2 dommages physiques) et esprit (1 dommage 
+  magique).
+- Son action spéciale est de prier.
+- Toutes les 3 prières, il est exaucé : il récupère 10 points de vie, et sa 
+  prochaine attaque provoque 5 dommages magiques supplémentaires. 
+
+
+Travail à faire
+---------------
+
+1. Compléter l'implémentation du guerrier et de la classe abstraite `Character`.
+2. Vérifier votre travail avec les tests du guerrier.
+3. Compléter l'implémentation du mage, jusqu'à passage réussi des tests.
+4. Créer la classe du prêtre tel que décrit.
\ No newline at end of file