diff --git a/Cours/Chap_10_JUnit.pdf b/Cours/Chap_10_JUnit.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..deda164e096144b86b3337d5a9f46f20f817eaec
Binary files /dev/null and b/Cours/Chap_10_JUnit.pdf differ
diff --git a/Cours/Chap_11_JavaFX.pdf b/Cours/Chap_11_JavaFX.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..268f4d5e2c9b6a12fea04075fc64e6c97a5cd54a
Binary files /dev/null and b/Cours/Chap_11_JavaFX.pdf differ
diff --git a/Cours/exemple_Java_FX/Calculator.java b/Cours/exemple_Java_FX/Calculator.java
new file mode 100644
index 0000000000000000000000000000000000000000..1e354d816a5e933cc5c5ba67aed5235d665bda96
--- /dev/null
+++ b/Cours/exemple_Java_FX/Calculator.java
@@ -0,0 +1,29 @@
+package application;
+
+public class Calculator {
+ /**
+ * This method is used to make tha arithmetic calculations.
+ * Supports +, -, *, / operands.
+ * @param number1 First double number to calculate operaton
+ * @param number2 Second double number to calculate operaton
+ * @return double This returns the result of number1 operand number2.
+ */
+ public double calculate(double number1, double number2, String operator) {
+ switch (operator) {
+ case "+":
+ return number1 + number2;
+ case "-":
+ return number1 - number2;
+ case "*":
+ return number1 * number2;
+ case "/":
+ if (number2 == 0)
+ return 0;
+
+ return number1 / number2;
+ }
+
+ System.out.println("Unknown operator - " + operator);
+ return 0;
+ }
+}
diff --git a/Cours/exemple_Java_FX/Controller.java b/Cours/exemple_Java_FX/Controller.java
new file mode 100644
index 0000000000000000000000000000000000000000..414e7b7652509cd36e4c7eb2aa2a3adef3407ba1
--- /dev/null
+++ b/Cours/exemple_Java_FX/Controller.java
@@ -0,0 +1,70 @@
+package application;
+
+import javafx.event.ActionEvent;
+import javafx.fxml.FXML;
+import javafx.scene.control.Button;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.text.Text;
+
+public class Controller {
+ @FXML
+ private Text output;
+
+ private double number1 = 0;
+ private String operator = "";
+ private boolean start = true;
+
+ private Calculator calc = new Calculator();
+
+ @FXML
+ private void processAC(ActionEvent event) {
+ if (start) {
+ output.setText("0");
+ }
+
+ String value = "0";
+ output.setText("");
+ }
+
+ @FXML
+ private void processNumpad(ActionEvent event) {
+ if (start) {
+ output.setText("");
+ start = false;
+ }
+
+ String value = ((Button)event.getSource()).getText();
+ output.setText(output.getText() + value);
+ }
+
+ @FXML
+ private void processOperator(ActionEvent event) {
+ if (start) {
+ output.setText("0");
+ start = false;
+ }
+
+ String value = ((Button)event.getSource()).getText();
+
+ if (!"=".equals(value)) {
+ if (!operator.isEmpty())
+ if(output.getText().equals(""))
+ return;
+
+ operator = value;
+ number1 = Double.parseDouble(output.getText());
+ output.setText("");
+ }
+ else {
+ if (operator.isEmpty() || output.getText().equals(""))
+ return;
+
+ output.setText(String.valueOf(calc.calculate(number1, Double.parseDouble(output.getText()), operator)));
+ operator = "";
+ start = true;
+ }
+
+ }
+
+
+}
\ No newline at end of file
diff --git a/Cours/exemple_Java_FX/Main.java b/Cours/exemple_Java_FX/Main.java
new file mode 100644
index 0000000000000000000000000000000000000000..5a7e612de3604a23f69b334bff0da6c39af4b6d2
--- /dev/null
+++ b/Cours/exemple_Java_FX/Main.java
@@ -0,0 +1,36 @@
+package application;
+
+import javafx.application.Application;
+import javafx.fxml.FXMLLoader;
+import javafx.stage.Stage;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+
+public class Main extends Application {
+ @Override
+ /**
+ * This method load the window view of the calculator
+ * @param Stage primary stage to show the view
+ */
+ public void start(Stage primaryStage) {
+ try {
+ Parent root = FXMLLoader.load(getClass().getResource("WindowView.fxml"));
+ Scene scene = new Scene(root);
+ primaryStage.setScene(scene);
+ primaryStage.show();
+ System.out.println(Thread.currentThread().getName());
+
+
+ } catch(Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ /**
+ * This method launch the application
+ * @param String of arguments
+ */
+ public static void main(String[] args) {
+ launch(args);
+ }
+}
\ No newline at end of file
diff --git a/Cours/exemple_Java_FX/WindowView.fxml b/Cours/exemple_Java_FX/WindowView.fxml
new file mode 100644
index 0000000000000000000000000000000000000000..c3396161d0fe42ba98f6b00e96181ec333dc1579
--- /dev/null
+++ b/Cours/exemple_Java_FX/WindowView.fxml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.layout.HBox?>
+<?import javafx.scene.layout.StackPane?>
+<?import javafx.scene.layout.VBox?>
+<?import javafx.scene.shape.Rectangle?>
+<?import javafx.scene.text.Text?>
+
+<VBox alignment="CENTER" prefHeight="300" prefWidth="300" spacing="10" stylesheets="@application.css" xmlns="http://javafx.com/javafx/21" xmlns:fx="http://javafx.com/fxml/1" fx:controller="application.Controller">
+
+ <StackPane alignment="CENTER">
+ <Rectangle fill="TRANSPARENT" height="60" stroke="PINK" width="230" />
+ <Text fx:id="output" />
+ </StackPane>
+
+ <HBox alignment="CENTER" spacing="0">
+ <Button onAction="#processNumpad" prefWidth="60" text="7" />
+ <Button onAction="#processNumpad" prefWidth="60" text="8" />
+ <Button onAction="#processNumpad" prefWidth="60" text="9" />
+ <Button onAction="#processOperator" prefWidth="60" text="/" />
+ </HBox>
+
+ <HBox alignment="CENTER" spacing="0">
+ <Button onAction="#processNumpad" prefWidth="60" text="4" />
+ <Button onAction="#processNumpad" prefWidth="60" text="5" />
+ <Button onAction="#processNumpad" prefWidth="60" text="6" />
+ <Button onAction="#processOperator" prefWidth="60" text="*" />
+ </HBox>
+
+ <HBox alignment="CENTER" spacing="0">
+ <Button onAction="#processNumpad" prefWidth="60" text="1" />
+ <Button onAction="#processNumpad" prefWidth="60" text="2" />
+ <Button onAction="#processNumpad" prefWidth="60" text="3" />
+ <Button onAction="#processOperator" prefWidth="60" text="-" />
+ </HBox>
+
+ <HBox alignment="CENTER" spacing="0">
+ <Button onAction="#processAC" prefWidth="60" text="AC" />
+ <Button onAction="#processNumpad" prefWidth="60" text="0" />
+ <Button onAction="#processOperator" prefWidth="60" text="=" />
+ <Button onAction="#processOperator" prefWidth="60" text="+" />
+ </HBox>
+</VBox>
diff --git a/Cours/exemple_Java_FX/application.css b/Cours/exemple_Java_FX/application.css
new file mode 100644
index 0000000000000000000000000000000000000000..d6094461e5d0be3ace25c70ac3a6a631ce7ce75b
--- /dev/null
+++ b/Cours/exemple_Java_FX/application.css
@@ -0,0 +1,12 @@
+.button{
+-fx-background-color: none,
+ rgba(0,0,0,0.08),
+ linear-gradient(#9a9a9a, #909090),
+ linear-gradient(white 0%, #f3f3f3 50%, #ececec 51%, #f2f2f2 100%);
+-fx-background-insets: 0 0 -1 0,0,1;}
+
+.button:hover{
+-fx-background-color: pink;}
+
+.button:selected{
+-fx-background-color: yellow;}/* JavaFX CSS - Leave this comment until you have at least create one rule which uses -fx-Property */
\ No newline at end of file
diff --git "a/Exercices/corrig\303\251/serie9/Individu.java" "b/Exercices/corrig\303\251/serie9/Individu.java"
new file mode 100644
index 0000000000000000000000000000000000000000..dfcd05addac14e51f3fca2d8dd0e7c8df069d043
--- /dev/null
+++ "b/Exercices/corrig\303\251/serie9/Individu.java"
@@ -0,0 +1,104 @@
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.Month;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+
+import java.io.Serializable;
+import java.util.List;
+
+public class Individu implements Serializable {
+ // Enum pour les lieux de naissance
+ public enum LieuxDeNaissance {
+ TOKYO, PARIS, NAIROBI, LOS_ANGELES, BAMAKO, MOSCOU, CARACAS, TBILISSI
+ }
+
+ // Enum pour les hobbies
+ public enum Hobbies {
+ JEUX_VIDEO, SPORT, RANDONNÉE, SKI, CINÉMA, CUISINE, LECTURE
+ }
+
+ // Attributs privés
+ private final int taille;
+ private final LocalDateTime dateDeNaissance;
+ private final LieuxDeNaissance lieuDeNaissance;
+ private final int poids;
+ private final List<Hobbies> hobbies;
+
+ // Constructeur
+ public Individu(int taille, LocalDateTime dateDeNaissance, LieuxDeNaissance lieuDeNaissance, int poids, List<Hobbies> hobbies) {
+ if (taille < 150 || taille > 190) {
+ throw new IllegalArgumentException("La taille doit être comprise entre 150cm et 190cm.");
+ }
+ if (poids < 60 || poids > 100) {
+ throw new IllegalArgumentException("Le poids doit être compris entre 60kg et 100kg.");
+ }
+ this.taille = taille;
+ this.dateDeNaissance = dateDeNaissance;
+ this.lieuDeNaissance = lieuDeNaissance;
+ this.poids = poids;
+ this.hobbies = hobbies;
+ }
+
+ // Getters
+ public int getTaille() {
+ return taille;
+ }
+
+ public LocalDateTime getDateDeNaissance() {
+ return dateDeNaissance;
+ }
+
+ public LieuxDeNaissance getLieuDeNaissance() {
+ return lieuDeNaissance;
+ }
+
+ public int getPoids() {
+ return poids;
+ }
+
+ public List<Hobbies> getHobbies() {
+ return hobbies;
+ }
+
+ // Affichage lisible
+ @Override
+ public String toString() {
+ return String.format("Né le %s à %s, mesure %dcm, pèse %dkg, aime %s",
+ dateDeNaissance.toLocalDate(),
+ lieuDeNaissance,
+ taille,
+ poids,
+ hobbies.toString().replace("[", "").replace("]", ""));
+ }
+
+ // Affichage formaté pour la sauvegarde dans un fichier
+ public String toCSV() {
+ return String.format(
+ "%s,%s,%d,%d,%s",
+ dateDeNaissance.toLocalDate(),
+ lieuDeNaissance,
+ taille,
+ poids,
+ String.join(";", hobbies.stream().map(Enum::name).toList())
+ );
+ }
+
+ // Création d'un individu à partir d'une ligne CSV
+ public static Individu fromCSV(String csvLine) {
+ String[] parts = csvLine.split(",");
+ LocalDateTime dateDeNaissance = LocalDateTime.of(
+ LocalDate.parse(parts[0]),
+ LocalTime.of(0, 0)
+ );
+ LieuxDeNaissance lieuDeNaissance = LieuxDeNaissance.valueOf(parts[1]);
+ int taille = Integer.parseInt(parts[2]);
+ int poids = Integer.parseInt(parts[3]);
+ List<Hobbies> hobbies = Arrays.stream(parts[4].split(";"))
+ .map(Hobbies::valueOf)
+ .toList();
+ return new Individu(taille, dateDeNaissance, lieuDeNaissance, poids, hobbies);
+ }
+}
diff --git "a/Exercices/corrig\303\251/serie9/IndividuUtils.java" "b/Exercices/corrig\303\251/serie9/IndividuUtils.java"
new file mode 100644
index 0000000000000000000000000000000000000000..3093f6829870300ae4650d26d2188b43adf0c96d
--- /dev/null
+++ "b/Exercices/corrig\303\251/serie9/IndividuUtils.java"
@@ -0,0 +1,53 @@
+import java.time.LocalDateTime;
+import java.time.Month;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+
+public class IndividuUtils {
+
+ private static final Random RANDOM = new Random();
+
+ public static Individu createIndividu() {
+ int taille = 150 + RANDOM.nextInt(41);
+ int poids = 60 + RANDOM.nextInt(41);
+
+ int year = 1990 + RANDOM.nextInt(35);
+ int month = 1 + RANDOM.nextInt(12);
+ int day = 1 + RANDOM.nextInt(
+ LocalDateTime.of(
+ year, month, 1, 0, 0).getMonth().length(false)
+ );
+ int hour = RANDOM.nextInt(24);
+ int minute = RANDOM.nextInt(60);
+
+ LocalDateTime dateDeNaissance = LocalDateTime.of(year, month, day, hour, minute);
+
+ Individu.LieuxDeNaissance lieuDeNaissance = Individu.LieuxDeNaissance.values()[
+ RANDOM.nextInt(Individu.LieuxDeNaissance.values().length)
+ ];
+
+ List<Individu.Hobbies> hobbiesList = Arrays.asList(Individu.Hobbies.values());
+ List<Individu.Hobbies> hobbies = new ArrayList<>();
+ int numberOfHobbies = 1 + RANDOM.nextInt(hobbiesList.size());
+
+ for (int i = 0; i < numberOfHobbies; i++) {
+ Individu.Hobbies hobby;
+ do {
+ hobby = hobbiesList.get(RANDOM.nextInt(hobbiesList.size()));
+ } while (hobbies.contains(hobby));
+ hobbies.add(hobby);
+ }
+
+ return new Individu(taille, dateDeNaissance, lieuDeNaissance, poids, hobbies);
+ }
+
+ public static List<Individu> createIndividus(int n) {
+ List<Individu> individus = new ArrayList<>();
+ for (int i = 0; i < n; i++) {
+ individus.add(createIndividu());
+ }
+ return individus;
+ }
+}
diff --git "a/Exercices/corrig\303\251/serie9/Test0.java" "b/Exercices/corrig\303\251/serie9/Test0.java"
new file mode 100644
index 0000000000000000000000000000000000000000..397c50303bae1949d04b9c1ac54402698f7727e5
--- /dev/null
+++ "b/Exercices/corrig\303\251/serie9/Test0.java"
@@ -0,0 +1,16 @@
+import java.util.List;
+
+public class Test0 {
+ public static void main(String[] args) {
+ System.out.println("Création d'un individu aléatoire :");
+ Individu individu = IndividuUtils.createIndividu();
+ System.out.println(individu);
+
+ System.out.println();
+ System.out.println("Création de 5 individus aléatoires :");
+ List<Individu> individus = IndividuUtils.createIndividus(5);
+ for (Individu i : individus) {
+ System.out.println(i);
+ }
+ }
+}
diff --git "a/Exercices/corrig\303\251/serie9/Test1.java" "b/Exercices/corrig\303\251/serie9/Test1.java"
new file mode 100644
index 0000000000000000000000000000000000000000..2201f017bcc7b5ed75d105d68bfea5bc931481e2
--- /dev/null
+++ "b/Exercices/corrig\303\251/serie9/Test1.java"
@@ -0,0 +1,80 @@
+import java.time.Month;
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Test1 {
+ public static void main(String[] args) {
+ // Générer une liste de 100 individus aléatoires
+ List<Individu> individus = IndividuUtils.createIndividus(100);
+
+ // 1. Afficher tous les individus nés en 2000 au mois de mars
+ System.out.println("Individus nés en 2000 au mois de mars :");
+ individus.stream()
+ .filter(i -> i.getDateDeNaissance().getYear() == 2000)
+ .filter(i -> i.getDateDeNaissance().getMonth() == Month.MARCH)
+ .forEach(System.out::println);
+
+ // 2. Afficher les 5 premiers individus nés en juillet 1993
+ System.out.println("\nLes 5 premiers individus nés en juillet 1993 :");
+ individus.stream()
+ .filter(i -> i.getDateDeNaissance().getYear() == 1993)
+ .filter(i -> i.getDateDeNaissance().getMonth() == Month.JULY)
+ .limit(5)
+ .forEach(System.out::println);
+
+ // 3. Afficher le nombre total d'individus nés en 1994
+ long count1994 = individus.stream()
+ .filter(i -> i.getDateDeNaissance().getYear() == 1994)
+ .count();
+ System.out.println("\nNombre total d'individus nés en 1994 : " + count1994);
+
+ // 4. Afficher les 5 plus grands individus nés au mois de décembre de l'année 2001
+ System.out.println("\nLes 5 plus grands individus nés en décembre 2001 :");
+ individus.stream()
+ .filter(i -> i.getDateDeNaissance().getYear() == 2001)
+ .filter(i -> i.getDateDeNaissance().getMonth() == Month.DECEMBER)
+ .sorted(Comparator.comparingInt(Individu::getTaille).reversed())
+ .limit(5)
+ .forEach(System.out::println);
+
+ // 5. Afficher les 5 plus petits individus de taille au moins 180cm nés en 2002
+ System.out.println("\nLes 5 plus petits individus (≥ 180cm) nés en 2002 :");
+ individus.stream()
+ .filter(i -> i.getDateDeNaissance().getYear() == 2002)
+ .filter(i -> i.getTaille() >= 180)
+ .sorted(Comparator.comparingInt(Individu::getTaille))
+ .limit(5)
+ .forEach(System.out::println);
+
+ // 6. Afficher les 5 plus petits individus de taille au moins 180cm nés en 2002 par ordre décroissant de taille
+ System.out.println("\nLes 5 plus petits individus (≥ 180cm) nés en 2002 (ordre décroissant) :");
+ individus.stream()
+ .filter(i -> i.getDateDeNaissance().getYear() == 2002)
+ .filter(i -> i.getTaille() >= 180)
+ .sorted(Comparator.comparingInt(Individu::getTaille).reversed())
+ .limit(5)
+ .forEach(System.out::println);
+
+ // 7. Afficher la liste (sans redondance) des hobbies des 5 plus lourds parmi les 20 plus grands individus nés en 1999
+ System.out.println("\nHobbies (sans redondance) des 5 plus lourds parmi les 20 plus grands nés en 1999 :");
+ individus.stream()
+ .filter(i -> i.getDateDeNaissance().getYear() == 1999)
+ .sorted(Comparator.comparingInt(Individu::getTaille).reversed())
+ .limit(20)
+ .sorted(Comparator.comparingInt(Individu::getPoids).reversed())
+ .limit(5)
+ .flatMap(i -> i.getHobbies().stream())
+ .distinct()
+ .forEach(System.out::println);
+
+ // 8. Afficher la liste (sans redondance) des mois de naissance des 20 plus grands individus nés en 1997
+ System.out.println("\nMois de naissance (sans redondance) des 20 plus grands nés en 1997 :");
+ individus.stream()
+ .filter(i -> i.getDateDeNaissance().getYear() == 1997)
+ .sorted(Comparator.comparingInt(Individu::getTaille).reversed())
+ .limit(20)
+ .map(i -> i.getDateDeNaissance().getMonth())
+ .distinct()
+ .forEach(System.out::println);
+ }
+}
diff --git "a/Exercices/corrig\303\251/serie9/Test2.java" "b/Exercices/corrig\303\251/serie9/Test2.java"
new file mode 100644
index 0000000000000000000000000000000000000000..c0f932e79a3cddf377bf4bbab174919d516bf34d
--- /dev/null
+++ "b/Exercices/corrig\303\251/serie9/Test2.java"
@@ -0,0 +1,130 @@
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.Month;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.FileReader;
+import java.io.BufferedReader;
+import java.io.IOException;
+
+public class Test2 {
+ // Méthode surchargée pour contrôler le type de liste (ArrayList)
+ public static List<Individu> createIndividusArrayList(int n) {
+ return new ArrayList<>(IndividuUtils.createIndividus(n));
+ }
+
+ // Méthode surchargée pour contrôler le type de liste (LinkedList)
+ public static List<Individu> createIndividusLinkedList(int n) {
+ return new LinkedList<>(IndividuUtils.createIndividus(n));
+ }
+
+ // Méthode surchargée pour contrôler la source avec Supplier
+ public static List<Individu> createIndividus(Supplier<Individu> supplier, int n) {
+ List<Individu> individus = new ArrayList<>();
+ for (int i = 0; i < n; i++) {
+ individus.add(supplier.get());
+ }
+ return individus;
+ }
+
+ // Méthode test pour afficher la liste des individus
+ public static void test(List<Individu> individus) {
+ individus.forEach(individu -> {
+ System.out.println(individu);
+ System.out.println("Hobbies: " + individu.getHobbies());
+ });
+ }
+
+ // Méthode surchargée pour effectuer l'action de "sortie"
+ public static void testWithConsumer(List<Individu> individus, Consumer<Individu> consumer) {
+ individus.forEach(consumer);
+ }
+
+ // Consumer pour écrire dans un fichier
+ public static Consumer<Individu> writeToFileConsumer(String fileName) {
+ return individu -> {
+ try (FileWriter writer = new FileWriter(fileName, true)) {
+ writer.write(individu.toCSV() + "\n");
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ };
+ }
+
+ // Supplier pour lire depuis un fichier
+ public static Supplier<Individu> readFromFileSupplier(String fileName) {
+ return new Supplier<>() {
+ private BufferedReader reader;
+ {
+ try {
+ reader = new BufferedReader(new FileReader(new File(fileName)));
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+
+ @Override
+ public Individu get() {
+ try {
+ if (reader != null) {
+ String line = reader.readLine();
+ if (line != null) {
+ return Individu.fromCSV(line);
+ }
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ return null;
+ }
+ };
+ }
+
+ // Main pour tester les méthodes
+ public static void main(String[] args) {
+ System.out.println("Créer des individus avec ArrayList :");
+ List<Individu> individusArrayList = createIndividusArrayList(5);
+ test(individusArrayList);
+
+ System.out.println("\nCréer des individus avec LinkedList :");
+ List<Individu> individusLinkedList = createIndividusLinkedList(5);
+ test(individusLinkedList);
+
+ System.out.println("\nCréer des individus avec Supplier :");
+ Supplier<Individu> singleSupplier = () -> new Individu(
+ 170,
+ LocalDateTime.of(1995, Month.JANUARY, 1, 0, 0),
+ Individu.LieuxDeNaissance.PARIS,
+ 70,
+ List.of(Individu.Hobbies.CINÉMA, Individu.Hobbies.SPORT)
+ );
+
+ // ou
+ // Supplier<Individu> singleSupplier = () -> IndividuUtils.createFixedIndividu();
+
+ List<Individu> individusFromSupplier = createIndividus(singleSupplier, 3);
+ test(individusFromSupplier);
+
+ System.out.println("\nTester avec un Consumer :");
+ String fileName = "individus.csv";
+ Consumer<Individu> fileWriterConsumer = writeToFileConsumer(fileName);
+ testWithConsumer(individusArrayList, fileWriterConsumer);
+
+ System.out.println("\nLire depuis le fichier avec Supplier :");
+ Supplier<Individu> fileReaderSupplier = readFromFileSupplier(fileName);
+ Individu individuFromFile;
+ while ((individuFromFile = fileReaderSupplier.get()) != null) {
+ System.out.println("Lu depuis le fichier : " + individuFromFile);
+ }
+ }
+}