mickbuilder / advanced_java Goto Github PK

On souhaite maintenant introduire une commande substitute(pattern, replacement) qui dans une ligne remplace toutes les occurrences du motif par une chaîne de caractère de remplacement. Malheureusement, notre enum Action n'est pas à même de gérer ce cas, car il faut que la commande puisse renvoyer PRINT mais avec une nouvelle ligne.
On se propose pour cela de remplacer l'enum Action par une interface et DELETE et PRINT par des records implantant cette interface comme ceci

private interface Action {
    record DeleteAction() implements Action {}
    record PrintAction(String text) implements Action {}
}

Modifier votre code sans introduire pour l'instant la commande substitute pour utiliser l'interface Action au lieu de l'enum.
Vérifier que les tests JUnit marqués "Q7" passent.
Rappel : on peut faire un switch sur des objets (des Actions) en Java.

Dans quel cas va-t-on utiliser une inner class plutôt qu'une classe interne ?

Optionnellement, faire en sorte que l'on puisse ajouter un discount suivi d'un pourcentage de réduction, c'est à dire un entier entre 0 et 100, en implantant une méthode addDiscount(kind, percent). Ajouter également une méthode priceByDiscount qui renvoie une table associative qui a un pourcentage renvoie la somme des prix par nuit auxquels on a appliqué ce pourcentage (la somme est aussi un entier). La somme totale doit être la même que la somme de tous les prix par nuit (donc ne m'oubliez pas les minions). Comme précédemment, les pourcentages ne se cumulent pas si on appelle addDiscount plusieurs fois.
Écrire les méthodes addDiscount(kind, percent) et priceByDiscount et vérifier que les tests JUnit marqués "Q10" passent.
Attention : pour un pourcentage de 10 (donc 10%), cela veut dire que le prix de la nuit doit être 90% du prix initial (100% moins 10% de discount).

1. Écrire le code de VillagePeople tel que l'on puisse créer des VillagePeople avec leur nom et leur sorte. Par exemple,

  var lee = new VillagePeople("Lee", Kind.BIKER);
  System.out.println(lee);  // Lee (BIKER)

L'affichage d'un VillagePeople affiche son nom, puis sa sorte entre parenthèses comme dans l'exemple ci-dessus.
Vérifier que les tests JUnit marqués "Q1" passent.
Attention, il y a toujours un problème avec les tests, si ceux-ci passent, on ne sait pas si le code est correct, car il peut aussi manquer un test qui va montrer que le code n'est pas correct. On sait juste que le code n'est pas bon quand les tests ne marchent pas.

On va maintenant chercher à implanter la méthode subSlice(from, to) directement dans l'interface Slice3. Ainsi, l'implantation sera partagée.
Écrire la méthode subSlice(from, to) en utilisant là encore une classe anonyme.
Comme l'implantation est dans l'interface, on n'a pas accès au tableau qui n'existe que dans l'implantation donnée dans la méthode array(array)... mais ce n'est pas grave, car on peut utiliser les méthodes de l'interface.
Puis fournissez une implantation à la méthode array(array, from, to).
Vérifier que les tests JUnit marqués "Q3" et "Q4" passent.

En fait, avoir une maison qui ne peut accepter que des VillagePeople n'est pas une bonne décision en termes de business, ils ne sont pas assez nombreux. YMCA décide donc qu'en plus des VillagePeople ses maisons permettent maintenant d'accueillir aussi des Minions, une autre population sans logement.
On souhaite donc ajouter un type Minion (qui possède juste un nom name) et changer le code de House pour permettre d'ajouter des VillagePeople ou des Minion. Un Minion affiche son nom suivi entre parenthèse du texte "MINION".
Vérifier que les tests JUnit marqués "Q4" passent.
Note : on souhaite qu'il soit possible d'ajouter dans le futur d'autres personnes que des VillagePeople et des Minion...

Le but de cet exercice est d'implanter l'interface Slice4 qui possède les mêmes méthodes que l'interface Slice mais au lieu d'avoir deux implantations, on va simplifier les choses en ayant une seule implantation.
De plus, au lieu d'utiliser une classe interne, une inner class ou une classe anonyme, on va utiliser une feature assez méconnue de Java : on peut avoir plusieurs classes/interfaces les unes derrières les autres dans un même fichier en Java, pourvu qu'une seule classe/interface soit publique.

Les tests JUnit 5 de cet exercice sont Slice4Test.java.

Le but de cet exercice est de créer un petit éditeur comme sed.
Pour ceux qui ne connaîtraient pas sed, c'est un utilitaire en ligne de commande qui prend en entrée un fichier et génère en sortie un nouveau fichier en effectuant des transformations ligne à ligne. sed permet facilement de supprimer une ligne soit spécifiée par son numéro, soit si elle contient une expression régulière ou de remplacer un mot (en fait une regex) par un mot.
L'utilitaire sed traite le fichier ligne à ligne, il ne stocke pas tout le fichier en mémoire (ce n'était pas une solution viable à la création de sed en 1974). On parle de traitement en flux, en stream en Anglais, d'où le nom de Stream EDitor, sed.

Les tests JUnit 5 de cet exercice sont StreamEditorTest.java.

On souhaite ajouter une surcharge à la méthode array qui, en plus de prendre le tableau en paramètre, prend deux indices from et to et montre les éléments du tableau entre from inclus et to exclus.
Par exemple

String[] array = new String[] { "foo", "bar", "baz", "whizz" };
Slice<String> slice = Slice.array(array, 1, 3);

En terme d'implantation, on va créer une autre classe interne nommée SubArraySlice implantant l'interface Slice.
Vérifier que les tests JUnit marqués "Q3" passent.
Note : pour l'affichage, il existe une méthode Arrays.stream(array, from, to) dans la classe java.util.Arrays

Recopier l'interface Slice du premier exercice dans une interface Slice3. Supprimer la classe interne SubArraySlice ainsi que la méthode array(array, from, to) car nous allons les réimplanter et commenter la méthode subSlice(from, to) de l'interface, car nous allons la réimplanter plus tard.
Puis déplacer la classe ArraySlice à l'intérieur de la méthode array(array) et transformer celle-ci en classe anonyme.
Vérifier que les tests JUnit marqués "Q1" et "Q2" passent.

L'implantation précédente pose problème : il est possible d'ajouter une autre personne qu'un VillagePeople ou un Minion, mais celle-ci ne sera pas prise en compte par le pattern matching. Pour cela, on va interdire qu'une personne soit autre chose qu'un VillagePeople ou un Minion en scellant le super type commun.
Faite les changements qui s'imposent et vérifier que les tests JUnit marqués "Q7" passent.
Note : il ne devrait pas y avoir de cas default dans votre switch !

En fait, cette implantation n'est pas satisfaisante car elle ajoute une méthode publique dans VillagePeople et Minion alors que c'est un détail d'implantation. Au lieu d'utiliser la POO (programmation orienté objet), on va utiliser la POD (programmation orienté data) qui consiste à utiliser le pattern matching pour connaître le prix par nuit d'un VillagePeople ou un Minion.
Modifier votre code pour introduire une méthode privée qui prend en paramètre un VillagePeople ou un Minion et renvoie son prix par nuit puis utilisez cette méthode pour calculer le prix moyen par nuit d'une maison.
Vérifier que les tests JUnit marqués "Q6" passent.
Note: le pattern matching, le switch sur des objets est une preview feature qui doit être activé à la compilation ainsi qu'à l'exécution.

Enfin, on souhaite pouvoir supprimer l'offre commerciale (discount) en ajoutant la méthode removeDiscount qui supprime le discount si celui-ci a été ajouté précédemment ou plante s'il n'y a pas de discount pour la sorte prise en paramètre.
Implanter la méthode removeDiscount et vérifier que les tests JUnit marqués "Q9" passent.

Dans quel cas va-t-on utiliser une classe anonyme plutôt qu'une classe interne ?

On veut périodiquement faire un geste commercial pour une maison envers une catégorie/sorte de VillagePeople en appliquant une réduction de 80% pour tous les VillagePeople ayant la même sorte (par exemple, pour tous les BIKERs). Pour cela, on se propose d'ajouter une méthode addDiscount qui prend une sorte en paramètre et offre un discount pour tous les VillagePeople de cette sorte. Si l'on appelle deux fois addDiscount avec la même sorte, le discount n'est appliqué qu'une fois.
Implanter la méthode addDiscount et vérifier que les tests JUnit marqués "Q8" passent.
Attention à l'algo, les discounts ne doivent pas être stockés dans une liste, il y a plus efficace !

On peut enfin ajouter la commande substitute(pattern, replacement) telle que le code suivant fonctionne

 var command = StreamEditor.substitute(Pattern.compile("foo|bar"), "hello");
 var editor = new StreamEditor(command);
 editor.transform(reader, writer);

Écrire le code de la méthode substitute et vérifier que les tests JUnit marqués "Q8" passent.

On va dans un premier temps créer une interface Slice avec une méthode array qui permet de créer un slice à partir d'un tableau en Java.

String[] array = new String[] { "foo", "bar" };
Slice<String> slice = Slice.array(array);

L'interface Slice est paramétrée par le type des éléments du tableau et permet que les éléments soient null.
L'interface Slice possède deux méthodes d'instance, size qui renvoie le nombre d'éléments et get(index) qui renvoie le index-ième (à partir de zéro).
En termes d'implantation, on va créer une classe interne à l'interface Slice nommée ArraySlice implantant l'interface Slice. L'implantation ne doit pas recopier les valeurs du tableau donc un changement d'une des cases du tableau doit aussi être visible si on utilise la méthode get(index).
Implanter la classe Slice et les méthodes array, size et get(index).
Vérifier que les tests JUnit marqués "Q1" passent.

En fait, cette implantation n'est pas satisfaisante, car les records LineDeleteCommand et FindAndDeleteCommand ont beaucoup de code qui ne sert à rien. Il serait plus simple de les transformer en lambdas, car la véritable information intéressante est comment effectuer la transformation d'une ligne.
Modifier votre code pour que les implantations des commandes renvoyées par les méthodes lineDelete et findAndDelete soit des lambdas.
Vérifier que les tests JUnit marqués "Q6" passent.

Dé-commenter la méthode subSlice(from, to) de l'interface et fournissez une implantation de cette méthode dans les classes ArraySlice et SubArraySlice.
On peut noter qu'il est désormais possible de simplifier le code de array(array, from, to).
Vérifier que les tests JUnit marqués "Q4" passent.

Le but de cet exercice est d'implanter l'interface Slice2 qui possède les mêmes méthodes que l'interface Slice mais on souhaite de la classe SubArraySlice soit une inner class de la classe ArraySlice.

Les tests JUnit 5 de cet exercice sont Slice2Test.java.

After finish the lab, the requirement merge

On veut maintenant pouvoir spécifier une commande à la création du StreamEditor pour transformer les lignes du fichier en entrée. Ici, lineDelete renvoie un record LineDeleteCommand qui indique la ligne à supprimer (la première ligne d'un fichier est 1, pas 0).
L'exemple ci-dessous montre comment supprimer la ligne 2 d'un fichier.

var command = StreamEditor.lineDelete(2);
var editor = new StreamEditor(command);
editor.transform(reader, writer);

L'idée est la suivante : on parcourt le fichier ligne à ligne comme précédemment, mais si le numéro de la ligne courante est égal à celui de la ligne à supprimer, alors on ne l'écrit pas dans le Writer.
Vérifier que les tests JUnit marqués "Q2" passent.
Note : LineNumberReader compte le nombre de lignes.
Note 2 : Il faut que le code utilisant le constructeur sans paramètre continue de fonctionner.

Dans un premier temps, on va créer une classe StreamEditor dans le package fr.uge.sed avec une méthode d'instance transform qui prend en paramètre un LineNumberReader et un Writer et écrit, ligne à ligne, le contenu du LineNumberReader dans le Writer.
Rappel, un BufferedReader possède une méthode readLine() et un Writer une méthode append().
Comme on veut que le programme fonctionne de la même façon, quelle que soit la plate-forme, le retour à la ligne écrit dans le Writer est toujours '\n'.
Vérifier que les tests JUnit marqués "Q1" passent.

Comme pour le TP précédent, nous allons utiliser Maven avec une configuration (le pom.xml) très similaire, ici nous n'avons pas besoin du pattern matching, donc pas besoin d'activer les preview features.

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>fr.uge.slice</groupId>
    <artifactId>slice</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.9.0</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.10.1</version>
                <configuration>
                    <release>19</release>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.0.0-M7</version>
            </plugin>
        </plugins>
    </build>
</project>

Comme précédemment, créer un projet Maven, au niveau du premier écran, cocher create simple project puis passer à l'écran suivant en indiquant Next.
Pour ce TP, le groupId est fr.uge.slice , l'artefactId est slice et la version est 0.0.1-SNAPSHOT. Puis cliquer sur Finish.

Un slice est une structure de données qui permet de "virtuellement" découper un tableau en gardant des indices de début et de fin (from et to) ainsi qu'un pointeur sur le tableau. Cela évite de recopier tous les éléments du tableau, c'est donc beaucoup plus efficace.
Le concept d'array slicing est un concept très classique dans les langages de programmation, même si chaque langage vient souvent avec une implantation différente.

Les tests JUnit 5 de cet exercice sont SliceTest.java.

Maintenant que l'on a bien préparé le terrain, on peut ajouter une nouvelle commande renvoyée par la méthode findAndDelete qui prend en paramètre un java.util.regex.Pattern telle que le code suivant fonctionne

var command = StreamEditor.findAndDelete(Pattern.compile("foo|bar"));
var editor = new StreamEditor(command);
editor.transform(reader, writer);

Faite les changements qui s'imposent puis vérifier que les tests JUnit marqués "Q5" passent.
Rappel : pour voir si un texte contient un motif pattern, on instancie un Matcher du motif sur le texte et on utilise la méthode find sur ce Matcher.

On cherche à ajouter une méthode averagePrice à House qui renvoie le prix moyen pour une nuit sachant que le prix pour une nuit pour un VillagePeople est 100 et le prix pour une nuit pour un Minion est 1 (il vaut mieux être du bon côté du pistolet à prouts). Le prix moyen (renvoyé par averagePrice) est la moyenne des prix des VillagePeople et Minion présent dans la maison.
Écrire la méthode averagePrice en utilisant le polymorphisme (late dispatch) pour trouver le prix de chaque VillagePeople ou Minion.
Vérifier que les tests JUnit marqués "Q5" passent.
Note : dans le cas où la maison est vide, on renverra NaN (Not A Number).

Déclarer une classe SubArraySlice à l'intérieur de la classe ArraySlice comme une inner class donc pas comme une classe statique et implanter cette classe et la méthode array(array, from, to).
Vérifier que les tests JUnit marqués "Q3" passent.

Optionnellement, créer une DeleteAction avec un new semble bizarre car une DeleteAction est un record qui n'a pas de composant donc on pourrait toujours utiliser la même instance.
Comment faire tout en gardant le record DeleteAction pour éviter de faire un new à chaque fois que l'on veut avoir une instance de DeleteAction ?
En fait, il y a une façon plus élégante de faire la même chose que la précédente en transformant DeleteAction en enum (chercher "enum singleton java" sur internet).

Recopier l'interface Slice de l'exercice précédent dans une interface Slice2. Vous pouvez faire un copier-coller de Slice dans même package, votre IDE devrait vous proposer de renommer la copie. Puis supprimer la classe interne SubArraySlice ainsi que la méthode array(array, from, to) car nous allons les réimplanter et commenter la méthode subSlice(from, to) de l'interface, car nous allons la ré-implanter aussi, mais plus tard.
Vérifier que les tests JUnit marqués "Q1" et "Q2" passent.

On souhaite introduire une nouvelle commande qui permet de supprimer une ligne si elle contient une expression régulière. Avant de le coder, on va faire un peu de re-factoring pour préparer le fait que l'on puisse choisir entre des commandes différentes.
L'idée est que chaque commande doit posséder une méthode que l'on pourra appeler avec la ligne courante (une String) et son numéro et qui renvoie une action à effectuer. L'action peut être soit DELETE pour indiquer que la ligne ne doit pas être affichée, soit PRINT pour indiquer que la ligne doit être affichée.
Pour cela, on va utiliser l'enum suivant

enum Action {
   DELETE, PRINT
 }

On pourrait utiliser un booléen comme type de retour, mais DELETE/PRINT c'est plus parlant que true/false.
Changer le code pour que le record LineDeleteCommand possède la méthode décrite plus haut et changer le code de transform pour qu'elle appelle cette méthode.
Vérifier que les tests JUnit marqués "Q4" passent.
Note : au lieu de mettre l'enum dans un fichier .java dans le même package, on va le ranger dans StreamEditor. En Java, mettre un enum, un record ou une interface dans une classe ne pose pas de problème, par contre mettre une classe dans une classe est un peu plus compliqué, on verra ça plus tard.
Note 2 : si vous ne comprenez pas pourquoi la méthode doit aussi prendre en paramètre la ligne elle-même, lisez la question suivante...

Enfin, on peut vouloir combiner plusieurs commandes en ajoutant une méthode andThen à Command tel que le code suivant fonctionne.

 var command1 = StreamEditor.substitute(Pattern.compile("foo"), "hello");
 var command2 = StreamEditor.findAndDelete(Pattern.compile("baz"));
 var editor = new StreamEditor(command1.andThen(command2));
 editor.transform(reader), writer);

andThen doit appliquer la première commande puis la seconde (dans cet ordre).
Modifier Command pour introduire la méthode d'instance andThen.
Vérifier que les tests JUnit marqués "Q10" passent.

Dé-commenter la méthode subSlice(from, to) et fournissez une implantation de cette méthode.
Vérifier que les tests JUnit marqués "Q4" passent.

Le but de cet exercice est d'implanter l'interface Slice3 qui possède les mêmes méthodes que l'interface Slice mais on va transformer les classes ArraySlice et SubArraySlice en classes anonymes.

Les tests JUnit 5 de cet exercice sont Slice3Test.java.

Le but de cet exercice est de créer un ensemble d'objets permettant de modéliser une maison YMCA comme dans la chanson plutôt que comme dans la vraie vie.
Une maison House accueil des VillagePeople. Un VillagePeople possède un nom (name) ainsi qu'une sorte (kind) parmi COP, NATIVE, GI, BIKER, CONSTRUCTION, COWBOY, ADMIRAL, ATHLETE, GIGOLO et SAILOR.
Pour définir les différentes sortes de VillagePeople, on va utiliser un enum défini dans un fichier Kind.java comme ceci

public enum Kind {
  COP, NATIVE, GI, BIKER, CONSTRUCTION, COWBOY, ADMIRAL, ATHLETE, GIGOLO, SAILOR
}

Toutes les classes, enum, etc... doivent être définis dans le package fr.uge.ymca.

Les tests JUnit 5 de cet exercice sont HouseTest.java.

On veut maintenant introduire une maison House qui va contenir des VillagePeople. Une maison possède une méthode add qui permet d'ajouter un VillagePeople dans la maison (note : il est possible d'ajouter plusieurs fois le même). L'affichage d'une maison doit renvoyer le texte "House with" suivi des noms des VillagePeople ajoutés à la maison, séparés par une virgule. Dans le cas où une maison est vide, le texte est "Empty House".

var house = new House();
System.out.println(house);  // Empty House
var david = new VillagePeople("David", Kind.COWBOY);
var victor = new VillagePeople("Victor", Kind.COP);
house.add(david);
house.add(victor);
System.out.println(house);  // House with David, Victor

Vérifier que les tests JUnit marqués "Q2" passent.
Pour l'affichage, vous pouvez utiliser un StringBuilder.
Attention à ce que l'on ne puisse pas ajouter des VillagePeople null !

On peut remarquer qu'en programmation objet il y a une toujours une tension entre avoir une seule classe et donc avoir des champs qui ne servent pas vraiment pour certaines instances et avoir plusieurs classes ayant des codes très similaires, mais avec un nombre de champs différents.
L'orthodoxie de la POO voudrait que l'on ait juste le nombre de champs qu'il faut, en pratique, on a tendance à ne pas créer trop de classes, car plus on a de code plus c'est difficile de le faire évoluer.
À votre avis, pour cet exemple, est-il préférable d'avoir deux classes une pour les tableaux et une pour les tableaux avec des bornes ou une seule classe gérant les deux cas ?

En conclusion, dans quel cas, à votre avis, va-t-on utiliser des records pour implanter de différentes façons une interface et dans quel cas va-t-on utiliser des lambdas ?

On souhaite maintenant écrire un main qui prend en paramètre sur la ligne de commande un nom de fichier, supprime la ligne 2 de ce fichier et écrit le résultat sur la sortie standard.
Vérifier que les tests JUnit marqués "Q3" passent.
Note : on présupposera que le fichier et la sortie standard utilisent l'encodage UTF-8 (StandardCharsets.UTF_8)
Note 2 : pour transformer un OutputStream (un PrintStream est une sorte d'OutputStream) en Writer, on utilise un OutputStreamWriter et comme on veut spécifier l'encodage, on va utiliser le constructeur qui prend aussi un Charset en paramètre.
Rappel : vous devez utiliser un try-with-resources pour fermer correctement les ressources ouvertes.

Exercice 1 - Maven
Comme pour le TP précédent, nous allons utiliser Maven avec une configuration (le pom.xml) très similaire.

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>fr.uge.sed</groupId>
    <artifactId>sed</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.9.0</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.10.1</version>
                <configuration>
                    <release>19</release>
                    <compilerArgs>
                        <compilerArg>--enable-preview</compilerArg>
                    </compilerArgs>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.0.0-M7</version>
                <configuration>
                    <argLine>--enable-preview</argLine>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Créer un projet Maven en cochant create simple project au niveau du premier écran, puis passer à l'écran suivant en indiquant Next.
Pour ce TP, le groupId est fr.uge.sed , l'artefactId est sed et la version est 0.0.1-SNAPSHOT. Pour finir, cliquer sur Finish.

En fait on veut que l'affichage affiche les noms des VillagePeople dans l'ordre alphabétique, il va donc falloir trier les noms avant de les afficher. On pourrait créer une liste intermédiaire des noms puis les trier avec un appel à list.sort(null) mais cela commence à faire beaucoup de code pour un truc assez simple. Heureusement, il y a plus simple, on va utiliser un Stream pour faire l'affichage.
Dans un premier temps, ré-écrire le code de l'affichage (commenter l'ancien) pour utiliser un Stream sans se préoccuper du tri et vérifier que les tests de la question précédente passent toujours. Puis demander au Stream de se trier et vérifier que les tests marqués "Q3" passent.
Note : pour joindre les éléments d'un Stream qui sont des sous-types de CharSequence on utilise le collector Collectors.joining().
Note 2 : Lorsque l'on a une modification à effectuer, la démarche qui consiste dans un premier temps à changer le code en gardant l'ancien mode de fonctionnement puis introduire le nouveau mode de fonctionnement s'appelle faire du refactoring. On prépare le terrain pour ajouter la feature sans casser le code existant, puis on ajoute la nouvelle feature.

On souhaite que l'affichage d'un slice affiche les valeurs séparées par des virgules avec un '[' et un ']' comme préfixe et suffixe.
Par exemple,

var array = new String[] { "foo", "bar" };
var slice = Slice.array(array);
System.out.println(slice);   // [foo, bar]

En terme d'implantation, penser à utiliser un Stream avec le bon Collector !
Vérifier que les tests JUnit marqués "Q2" passent.

Déclarer l'interface Slice4 avec les méthodes size, get(index) et subSlice(from, to) abstraites. De plus, la méthode array(array) peut déléguer son implantation à la méthode array(array, from, to).
Pour l'instant, commenter la méthode subSlice(from, to) que l'on implantera plus tard.
À la suite du fichier, déclarer une classe non publique SliceImpl implantant l'interface Slice4 et implanter la méthode array(array, from, to).
Vérifier que les tests JUnit marqués "Q1", "Q2" et "Q3" passent

On souhaite enfin ajouter une méthode subSlice(from, to) à l'interface Slice qui renvoie un sous-slice restreint aux valeurs entre from inclus et to exclu.
Par exemple,

String[] array = new String[] { "foo", "bar", "baz", "whizz" };
Slice<String> slice = Slice.array(array);
Slice<String> slice2 = slice.subSlice(1, 3);

Bien sûr, cela veut dire implanter la méthode subSlice(from, to) dans les classes ArraySlice et SubArraySlice.
Vérifier que les tests JUnit marqués "Q4" passent.

Configuration de Maven