Compare revisions

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.

package fr.univamu.progav.td5;

public record Blow(int physicalDamage, int magicalDamage) {

}

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();

}

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

package fr.univamu.progav.td5;

public class Warrior extends Character {

  private static final int BASE_DAMAGE = 3;

  private static final int BASE_HEALTH = 30;

  public static final int RAGE_DAMAGE_THRESHOLD = 5;

  // TODO add rage

  public Warrior() {

    // TODO

  }

  @Override

  public Blow attack() {

    // TODO

    return null;

  }

  @Override

  public void defend(Blow blow) {

    // TODO

  }

  @Override

  public void specialAction() {

    // TODO

  }

  public int getRage() {

    // TODO

    return 0;

  }

}

package fr.univamu.progav.td5;

public class Wizard extends Character {

  private static final int BASE_HEALTH = 20;

  private static final int BASE_DAMAGE = 4;

  private static final int BASE_SHIELD_VALUE = 8;

  // TODO add shield

  public Wizard() {

    // TODO

  }

  @Override

  public Blow attack() {

    //TODO

    return null;

  }

  @Override

  public void defend(Blow blow) {

    // TODO

  }

  @Override

  public void specialAction() {

    // TODO

  }

  public int getShield() {

    // TODO

    return 0;

  }

}

package fr.univamu.progav.td6;

public class ArrayCellLens<T> implements Lens<T> {

  // TODO ajouter les propriétés

  public ArrayCellLens(T[] array, int index) {

    // TODO

  }

  @Override

  public T get() {

    // TODO

    return null;

  }

  @Override

  public void set(T t) {

    // TODO

  }

}

package fr.univamu.progav.td6;

public class Box implements Lens<Integer> {

  private int content;

  public Box(int content) {

    this.content = content;

  }

  @Override

  public void set(Integer newContent) {

    this.content = newContent;

  }

  @Override

  public Integer get() {

    return this.content;

  }

}

package fr.univamu.progav.td6;

public interface Lens<T> {

  void set(T t);

  T get();

}

package fr.univamu.progav.td6;

import java.util.List;

public class ListCellLens<T> implements Lens<T> {

  // TODO ajouter les propriétés

  public ListCellLens(List<T> list, int index) {

    // TODO

  }

  @Override

  public void set(T t) {

    // TODO

  }

  @Override

  public T get() {

    // TODO

    return null;

  }

}

Ces exercices ont pour sujet une interface `Lens` générique, permettant 

de représenter un emplacement mémoire autorisant la lecture et l'écriture.

Prendre connaissance de cette interface, qui propose deux méthodes `set`

et `get`.

Exercice 1

==========

Rendre la classe `Box` générique. Pour l'instant elle implémente un 

`Lens<Integer>`, mais nous voulons l'utiliser avec d'autres types.

Modifier la méthode de test `genericTest` de la classe `BoxTest` pour qu'elle 

fonctionne.

Exercice 2

==========

Étant donné une liste, chaque case de la liste est accessible en lecture et 

en écriture. Il est donc possible de décrire chaque case avec l'interface 

`Lens`. Compléter la classe générique `ListCellLens`, prenant une liste et 

l'indice d'une case en paramètre du constructeur, et représentant la case ainsi 

désignée.

Vérifiez votre travail à l'aide des tests `ListCellLensTest` associés à la 

classe.

Exercice 3

==========

Nous pouvons faire la même chose avec les tableaux. Compléter la classe 

générique `ArrayCellLens`, prenant un tableau et

l'indice d'une case en paramètre du constructeur, et représentant la case ainsi

désignée.

Vérifiez votre travail à l'aide des tests `ArrayCellLensTest` associés à la 

classe.

Exercice 4

==========

Si vous essayez d'utiliser `ArrayCellLens` avec un tableau de type `int[]`, 

cela produit une erreur à la compilation. Pourquoi ?

Ajouter une classe `IntArrayCellLens` pour pouvoir faire un `Lens` sur une 

case d'un tableau de type `int[]`.

Ajouter un test dans la classe `ArrayCellLensTest`, s'assurant du bon 

fonctionnement des méthodes `set` et `get` pour une case d'un tableau de 

type `int[]`

Exercice 5 (Optionnel)

======================

Nous pouvons utiliser un objet de type `Lens` pour stocker une valeur sous 

un format compressé. Pour un type `S` (dont les valeurs prennent beaucoup de 

place), si nous disposons d'une fonction de compression `f` vers un type `T` 

(nécessitant moins de place), et de son inverse `g`, nous pouvons 

représenter une valeur `s` de type `S` en stockant uniquement `f(s)`. La 

méthode `get` applique automatiquement `g` pour retrouver la valeur initiale 

(de type `S`). La méthode `set` applique automatiquement `f` pour ne stocker 

qu'une image (de type `T`). Ainsi, nous réduisons l'espace utilisé, en 

échange d'un coût de calcul des fonctions `f` et `g` `chaque opération.

Ajouter une interface `Bijection` permettant de représenter par deux 

méthodes les fonctions `f` et `g`.

Ensuite créer une classe `ConvertingLens`, de type `Lens<S>`, et ayant une 

propriété de type `T`. Le constructeur sera paramétré par la bijection à 

utiliser.

Tester avec `S = String`, `T = Integer`, en se restreignant aux chaînes de 

caractères correspondant à des nombres décimaux (comme `"129873"`)

package fr.univamu.progav.td7;

import java.util.Iterator;

import java.util.NoSuchElementException;

/** A class to represent sets of consecutive integers.

 * @param mini the smallest integer in the set.

 * @param maxi the largest integer in the set. If maxi < mini, the set is empty.

 */

public record Interval(int mini, int maxi) implements Iterable<Integer> {

  /**

   * @param i an arbitrary integer

   * @return true if i is in the set

   */

  public boolean contains(int i) {

    // TODO

    return false;

  }

  /**

   * @return the number of integers in the set.

   */

  public int size() {

    // TODO

    return -1;

  }

  /**

   * @return true if this is empty.

   */

  public boolean isEmpty() {

    // TODO

    return false;

  }

  /** Decide whether two intervals intersect each other.

   * @param range the second interval

   * @return true if this and range intersect

   */

  public boolean intersects(Interval range) {

    // TODO

    return false;

  }

  /**

   * @return an iterator over the integers in the set

   */

  @Override

  public Iterator<Integer> iterator() {

    return new Iterator<Integer>() {

      // TODO ajouter une propriété pour le prochain élément

      @Override

      public boolean hasNext() {

        // TODO

        return false;

      }

      @Override

      public Integer next() {

        if (!hasNext()) {

          throw new NoSuchElementException();

        }

        // TODO

        return null;

      }

    } ;

  }

}

package fr.univamu.progav.td7;

public class IntervalSequences {

  public static boolean containsEmptyInterval(Sequence<Interval> intervals) {

    // TODO

    return false;

  }

  public static int sumOfSizes(Sequence<Interval> intervals) {

    // TODO

    return -1;

  }

  public static Interval longestInterval(Sequence<Interval> intervals) {

    // TODO

    return null;

  }

}

package fr.univamu.progav.td7;

import java.util.Comparator;

import java.util.function.Consumer;

import java.util.function.Predicate;

public interface Sequence<T> {

  void forEach(Consumer<T> action);

  boolean anyMatch(Predicate<T> predicate);

  T maximum(Comparator<T> compare);

}

Cette semaine les exercices portent sur les classes anonymes, les lambdas et 

les références de méthodes.

Exercice 1

==========

Compléter la classe ```Interval``` qui représente des ensembles d'entiers 

consécutifs, comme $\{3,4,5,6,7\}$.

Pour la méthode ```iterator```, compléter la classe anonyme. Il faudra 

ajouter une propriété pour retenir le prochain entier de l'itération. 

Vérifier votre travail avec les tests de la classe ```IntervalTest```.

Exercice 2

==========

Une ```Sequence<T>``` ressemble à une ```List<T>```, mais on ne nous donne 

que des méthodes nécessitant un argument fonctionnel.

- ```forEach``` demande un ```Consumer<T>```, une action qui sera appliquée 

  à chaque élément de la séquence. L'interface ```Consumer<T>``` est définie 

  par 

```java

interface Consumer<T> {

  void accept(T value);

}

```

- ```anyMatch``` demande un ```Predicate<T>```, un prédicat pouvant être 

  appliqué aux éléments de la séquence. ```anyMatch``` renvoie ```true``` si au 

  moins un des éléments de la séquence satisfait le prédicat. L'interface 

  ```Predicate<T>``` est définie par

```java

interface Predicate<T> {

  boolean test(T value);

}

```

- ```maximum``` demande un ```Comparator<T>```, un objet capable de décider 

  quel est la plus grande de 2 valeurs de type ```T```. L'interface 

  ```Comparator<T>``` est définie par 

```java

interface Comparator<T> {

  int compare(T t1, T t2);

}

```

Compléter les méthodes statiques de la classe ```IntervalSequence```. Pour 

cela :

- pour ```containsEmptyInterval```, utiliser une référence de méthode pour 

  définir le prédicat "est vide" des intervalles.

- Pour ```sumOfSizes```, essayer d'utiliser une lambda avec un compteur 

  de type ```int```. Cela ne va pas fonctionner, pourquoi ? 

- Introduire une interface correspondant à un compteur entier :

```java

  interface IntCounter {

    void add(int value);

    int get();

  }

```

- Dans ```sumOfSizes```, créer un compteur à l'aide d'une classe anonyme, 

  puis utiliser ```forEach``` sur la séquence avec une lambda pour augmenter 

  le compteur.

- Dans ```longestInterval```, utiliser une lambdas.

- Vérifier votre travail avec les tests de la classe 

  ```IntervalSequencesTest```.

package fr.univamu.progav.td8;

import fr.univamu.progav.td1.ExercicesBoucles;

import java.util.*;

import java.util.function.BiConsumer;

import java.util.function.Supplier;

import java.util.stream.Collectors;

import java.util.stream.Stream;

public class ExercicesStream {

  public interface Person {

    int age();

    String name();

    boolean isFemale();

    Person mother();

    Person father();

    List<Person> children();

  }

  // Exercice : compléter toutes les méthodes suivantes

  // retourne vrai si la stream contient une femme

  public static boolean hasFemale(Stream<Person> persons) {

    // TODO

    return false;

  }

  // retourne vrai si la stream contient un individu homme et mineur (moins de 18 ans)

  public static boolean containsMinorMale(Stream<Person> persons) {

    // TODO

    return false;

  }

  // retourne un individu de la stream, femme et ayant au moins un enfant,

  // null si aucun individu ne convient

  public static Optional<Person> findMother(Stream<Person> persons) {

    // TODO

    return Optional.empty();

  }

  // retourne vrai si tous les individus de la stream sont majeurs (âge >= 18)

  public static boolean areAllMajor(Stream<Person> persons) {

    // TODO

    return false;

  }

  // retourne la liste de tous les hommes de la stream.

  public static List<Person> males(Stream<Person> persons) {

    // TODO

    return List.of();

  }

  // retourne le nombre de femmes de la stream

  public static long nbFemales(Stream<Person> persons) {

    // TODO

    return 0L;

  }

  // trouve un individu de la stream ayant un enfant, et retourne l'âge

  // de cet enfant.

  public static Optional<Integer> ageOfSomeChild(Stream<Person> persons) {

    // TODO

    return Optional.empty();

  }

  // retourne la personne la plus agée de la stream,

  public static Optional<Person> eldest(Stream<Person> persons) {

    // TODO

    return Optional.empty();

  }

  // retourne une chaîne de caractères, comprenant les noms de toutes les

  // personnes de la stream, dans l'ordre, séparés par une espace.

  public static String names(Stream<Person> persons) {

    // TODO

    return "";

  }

  // retourne l'âge moyen des individus de la stream

  public static OptionalDouble averageAge(Stream<Person> persons) {

    // TODO

    return OptionalDouble.empty();

  }

  private static class SexCount {

    // TODO ajouter des propriétés pour compter le nombre d'hommes et de femmes

    SexCount() {}

    void add(Person p) {

      // TODO dénombrer p dans les statistiques

    }

    void merge(SexCount count) {

      // TODO fusionner les statistiques

    }

    boolean areEquals() {

      // TODO renvoyer vrai si les nombres de femmes et d'hommes sont égaux

      return false;

    }

  }

  // retourne vrai si les nombres d'hommes et de femmes sont égaux.

  public static boolean hasAsManyMalesAsFemales(Stream<Person> persons) {

    Supplier<SexCount> supplier = null; // TODO initialiser les 3 variables.

    BiConsumer<SexCount, Person> accumulator = null;

    BiConsumer<SexCount,SexCount> combiner = null;

    return persons

      .collect(supplier,accumulator,combiner)

      .areEquals();

  }

}

Exercice

========

Compléter les méthodes de la classe `ExercicesStream`.

Vous devez utiliser des Stream. Il est interdit d'utiliser des boucles ou 

des récursions. Il est interdit de convertir les streams en listes (sauf 

pour calculer la liste à retourner dans la méthode ```males```). Toutes 

les méthodes doivent avoir une seule instruction, l'instruction ```return```.

La dernière méthode est la plus difficile, elle demande de construire un 

collecteur à partir de trois éléments :

- un ```Supplier<R>```, ```R``` étant le type des objets effectuant la 

  collection, disons un collecteur. Ce ```Supplier``` permet de créer un 

  nouveau collecteur; 

- un ```BiConsumer<R,People>```, qui est une fonction prenant un collecteur 

  et une personne collectée. C'est en général la méthode du collecteur 

  chargé d'accepter les personnes collectées l'une après l'autre. Le 

  collecteur met à jour son état interne pour tenir compte de la personne 

  collectée.

- un ```BiConsumer<R,R>```, qui est une fonction permettant de fusionner le 

  travail de deux collecteurs. Le premier collecteur agrège les données 

  récoltées par le deuxième collecteur dans son état interne.

Pour nous, le collecteur est un objet calculant le nombre de personnes de 

chaque sexe. Le premier argument sera donc son constructeur, le deuxième 

sera sa méthode ```add```, et le troisième sa méthode ```merge```, chacun 

pouvant être donné par une référence de méthode. Une fois le collecteur 

effectué, il reste à utiliser la méthode ```areEquals()``` pour déterminer 

si le nombre de femmes est égal au nombre d'hommes.

Tous les tests de ```ExercicesStreamTest``` doivent passer à la fin de 

l'exercice.

 No newline at end of file

package fr.univamu.progav.td9;

public record Book(String isbn, String title) {

  @Override

  public String toString() {

    return title + " (" + isbn + ")";

  }

}

package fr.univamu.progav.td9;

public class BookException extends Exception {

}