diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..8a9c163
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "Espace Formateur"]
+ path = Espace Formateur
+ url = git@github.com:Alex-Octocorn/Java-POO_Formateur.git
diff --git a/Espace Formateur b/Espace Formateur
new file mode 160000
index 0000000..fbe7787
--- /dev/null
+++ b/Espace Formateur
@@ -0,0 +1 @@
+Subproject commit fbe7787172081838cd98582b131ae5815a3d6b7d
diff --git a/README.md b/README.md
index 6af847b..67a2c0f 100644
--- a/README.md
+++ b/README.md
@@ -10,20 +10,25 @@ Nous aborderons les différents concepts, les bonnes pratiques de développement
## Plan de cours 🗺️
-
- [x] [Introduction](./cours/00_introduction.slides.md)
- Qu'est-ce que la programmation orientée objet ?
- Pourquoi utiliser la POO ?
- Introduction aux piliers de la POO
- Présentation générale de Java
- Installation de l'environnement de développement
-- [ ] [Les bases](./cours/01_bases.slides.md)
+- [x] [Les bases](./cours/01_bases.slides.md)
- Les variables
- Les opérateurs
- Les conditions
- Les boucles
- Les tableaux
- Les fonctions
+ - Classes et objets
+- [ ] [Aller plus loin](./cours/02_avance.slides.md)
+ - Exceptions
+ - Lambda
+ - Threads
+ - Généricité
- [ ] [Encapsulation](./cours/02_encapsulation.slides.md)
- Définition
- Les accesseurs
@@ -44,19 +49,6 @@ Nous aborderons les différents concepts, les bonnes pratiques de développement
- Utilisation
- Override
- Overload
-- [ ] [Exceptions](./cours/06_exceptions.slides.md)
- - Définition
- - Arborescence
- - Utilisation
-- [ ] [Lambda](./cours/07_lambda.slides.md)
- - Définition
- - Utilisation
-- [ ] [Threads](./cours/08_threads.slides.md)
- - Définition
- - Utilisation
-- [ ] [Généricité](./cours/10_genericite.slides.md)
- - Définition
- - Utilisation
## Suivre ce cours 📚
@@ -74,7 +66,8 @@ Vous aurez alors accès à une animation du cours, de démonstrations et de la c
Vous retrouverez les exercices dans le dossier `./exercices`.
-Pour chaque exercice, vous retrouverez trois niveaux de difficulté :
+Pour chaque exercice, vous retrouverez trois niveaux de difficulté :
+
- Coq : Version avancée de l'exercice, avec très peu d'indications
- Poulet : Version "classique", avec quelques indices
- Poussin : Version "guidée", avec rappels des notions importantes et indices supplémentaires
@@ -83,7 +76,8 @@ Pour chaque exercice, vous retrouverez trois niveaux de difficulté :
## Contribuer 🤝
-Vous pouvez contribuer à l'amélioration de ce cours en créant une *pull request* ou en remontant un problème dans la section "Issues" du dépôt.
+Vous pouvez contribuer à l'amélioration de ce cours en créant une *pull request* ou en remontant un problème dans la
+section "Issues" du dépôt.
Rendez-vous sur le [guide de contribution](./CONTRIBUTING.md) pour plus d'informations !
## Soutenir 🫶
diff --git a/cours/01_introduction.slides.md b/cours/01_introduction.slides.md
index fb9fa77..6a84c60 100644
--- a/cours/01_introduction.slides.md
+++ b/cours/01_introduction.slides.md
@@ -11,7 +11,9 @@ sources:
# POO
-
+
+
+
----
@@ -160,7 +162,9 @@ Nous aborderons ces concepts en détail dans les prochains chapitres !
# Java POO - Introduction
-
+
+
+
----
diff --git a/cours/02_bases.slides.md b/cours/02_bases.slides.md
index 65433ba..7eead37 100644
--- a/cours/02_bases.slides.md
+++ b/cours/02_bases.slides.md
@@ -17,3 +17,1242 @@ sources:
----
+## Java
+### Hello World
+
+Créez un nouveau projet Java **IntelliJ** :
+- File > New > Project > New Project
+- Sélectionnez l'archétype **Maven**
+- Dans les options avancées, ajoutez votre nom de domaine inversé (ex: `fr.octocorn`)
+- Laissez coché "Generate Sample Code"
+
+----
+
+## Java
+### Hello World
+
+Le projet a automatiquement été créé avec la structure suivante :
+
+```
+└───src # Racine du code source
+ ├───main # Code source principal
+ │ ├───java # Code source Java
+ │ │ └───fr # Dossier contenant le nom de domaine inversé
+ │ │ └───octocorn # On parle de package
+ │ │ Main.java # Fichier contenant la classe Main
+ │ │
+ │ └───resources # Code source non Java
+ └───test # Code source de tests
+```
+
+----
+
+## Java
+### Hello World
+
+La classe `Main` est la classe principale du programme.
+Elle contient la méthode `main` qui est la méthode principale du programme.
+
+```java
+public class Main {
+ public static void main(String[] args) {
+ System.out.println("Hello World!");
+ }
+}
+```
+
+> `System.out.println` permet d'afficher du texte dans la console
+
+----
+
+## Java
+### Hello World
+
+Pour exécuter le programme en ligne de commande :
+
+```shell
+java src/main/java/fr/octocorn/Main.java
+```
+
+> Vous pouvez aussi utiliser le bouton "Run" dans IntelliJ !
+
+----
+
+## Java
+### JavaDoc
+
+> Quelle est la différence entre un commentaire et une documentation ?
+
+----
+
+## Java
+### JavaDoc
+
+La documentation est un commentaire **structuré** et **formaté**.
+
+```java
+/**
+ * Cette classe représente une personne
+ */
+public class Personne {
+ // Code ...
+}
+```
+
+> Elle peut être lue depuis n'importe où en passant la souris sur le code !
+
+----
+
+## Java
+### JavaDoc
+
+La documentation peut être **formatée** avec des balises HTML.
+
+```java
+/**
+ * Cette classe représente une personne
+ *
+ * Une personne est caractérisée par son nom et son prénom
+ *
+ */
+public class Personne {
+ // Code ...
+}
+```
+
+----
+
+## Java
+### Commentaire
+
+Le commentaire est un texte **libre**.
+
+```java
+// Cette classe représente une personne
+public class Personne {
+ // Code ...
+}
+```
+
+- Elle ne peut pas être formatée
+- Elle ne peut pas être lue depuis n'importe où
+
+----
+
+## Java
+### Commentaire
+
+Le commentaire peut être **multi-lignes**.
+
+```java
+/*
+ * Cette classe représente une personne
+ */
+public class Personne {
+ // Code ...
+}
+```
+
+----
+
+## Java
+### Commentaire ou doc ?
+
+- **Commentaire** : Pour expliquer le code
+- **Documentation** : Pour décrire le code
+
+> En théorie, il ne devrait pas y avoir de commentaire dans le code si le code est bien écrit !
+
+----
+
+## Java
+### DOCUMENTEZ !
+
+Si en théorie, un code bien écrit n'a pas besoin de documentation :
+- La documentation est **obligatoire** pour les classes et les méthodes publiques
+- La documentation est **fortement recommandée** pour les classes et les méthodes privées
+
+> Bonne pratique ! 🤓
+
+---
+
+## Variables
+
+
+
+
+
+----
+
+## Variables
+### Définition
+
+Une variable est une **zone mémoire** dans laquelle on peut stocker une **valeur**.
+
+```java
+int age = 18;
+```
+
+- `int` est le **type** de la variable
+- `age` est le **nom** de la variable
+- `18` est la **valeur** de la variable
+
+> Une variable est une **référence** vers une valeur
+
+----
+
+## Variables
+### Définition
+
+- Elle est stockée dans la **mémoire vive** de l'ordinateur
+- Sa taille est allouée dynamiquement en fonction de son type
+- Elle peut être modifiée à tout moment
+- Elle peut être **référencée** par son nom
+
+----
+
+## Variables
+### Nommage
+
+- Bien nommer ses variables est **très important**
+- Utilisez des noms **significatifs** et **compréhensibles**
+- Pas d'**acrônyme** ou d'**abréviation** (sauf si connu de tous)
+- Ils sont déclarés en **camelCase**
+
+> Vous ne codez pas pour vous, mais pour les autres !
+
+----
+
+## Constantes
+### Définition
+
+- Une constante est une variable dont la valeur ne peut pas être modifiée
+- Elle est déclarée avec le mot clé `final`
+
+```java
+final int AGE_LIMITE = 18;
+```
+
+> Les constantes sont déclarées en **majuscules**
+
+----
+
+## Variables
+### Types numériques
+
+- En java, les types sont précisés **avant** le nom de la variable
+- Il existe plusieurs types numériques :
+ - `byte` : 8 bits
+ - `short` : 16 bits
+ - `int` : 32 bits
+ - `long` : 64 bits
+ - `float` : 32 bits (virgule flottante)
+ - `double` : 64 bits (virgule flottante)
+
+----
+
+## Variables
+### Types booléens
+
+- `boolean` : Vrai ou faux (1 bit)
+
+```java
+boolean estVrai = true;
+boolean estFaux = false;
+```
+
+----
+
+## Variables
+### Types caractères
+
+- `char` : Caractère unique (16 bits)
+- `String` : Chaine de caractères (tableau de `char`)
+
+```java
+char lettre = 'a';
+String mot = "Bonjour";
+```
+
+> Les `String` se déclarent avec `""` !
+
+----
+
+## Variables
+### String
+
+> Pourquoi `String` et pas `string` ?
+
+----
+
+## Variables
+### String
+
+- `String` est une **classe** et non un **type primitif**
+- Les classes commencent par une **majuscule**
+- Il s'agit d'un tableau de `char`, livré avec des méthodes
+
+----
+
+## Types
+### Types primitifs VS Classes
+
+- Les types primitifs sont **plus rapides** à manipuler
+- Les classes sont **plus pratiques** à manipuler
+- Elles ajoutent des **méthodes** et des **fonctionnalités**
+
+> Les classes sont des **wrappers** des types primitifs
+
+---
+
+## Opérateurs
+
+
+
+
+
+----
+
+## Opérateurs
+### Définition
+
+Un opérateur est un **symbole** qui permet d'effectuer une **opération** sur des variables.
+
+```java
+int a = 1;
+int b = 2;
+int c = a + b;
+```
+
+- `+` est l'**opérateur d'addition**
+- `a` et `b` sont les **opérandes**
+- `c` est le **résultat** de l'opération
+
+----
+
+## Opérateurs
+### Opérateurs arithmétiques
+
+- `+` : Addition
+- `-` : Soustraction
+- `*` : Multiplication
+- `/` : Division
+- `%` : Modulo (reste de la division)
+
+> Les opérateurs arithmétiques ne fonctionnent qu'avec des nombres !
+
+----
+
+## Opérateurs
+### Opérateurs de comparaison
+
+- `==` : Egalité
+- `!=` : Différence
+- `>` : Supérieur
+- `<` : Inférieur
+- `>=` : Supérieur ou égal
+- `<=` : Inférieur ou égal
+
+> Les opérateurs de comparaison renvoient un booléen !
+
+----
+
+## Opérateurs
+### Opérateurs logiques
+
+- `&&` : ET (Conjonction)
+- `||` : OU (Disjonction)
+- `!` : NON (Négation)
+
+----
+
+## Opérateurs
+### Opérateurs d'incrémentation
+
+- `++` : Incrémentation
+- `--` : Décrémentation
+
+```java
+int a = 1;
+a++; // a = a + 1
+a--; // a = a - 1
+```
+
+> Peut être placé avant ou après la variable
+
+----
+
+## Opérateurs
+### Concaténation
+
+- `+` : Concaténation
+- Equivalent : Méthode `concat` de la classe `String
+
+```java
+String a = "Hello";
+String b = "World";
+String c = a + " " + b; // "Hello World"
+```
+
+> La concaténation ne fonctionne qu'avec des `String` !
+
+----
+
+## Opérateurs
+### Opérateurs d'affectation
+
+- `=` : Affectation
+- `+=` : Affectation avec addition
+- `-=` : Affectation avec soustraction
+- `*=` : Affectation avec multiplication
+
+----
+
+## Opérateurs
+### Opérateurs ternaires
+
+- `? :` : Opérateur ternaire
+- Comparable à un `if` / `else`
+
+```java
+int a = 1;
+int b = 2;
+int c = a > b ? a : b; // c = b
+```
+
+> Eviter de l'utiliser, préférer un `if` / `else` !
+
+---
+
+## Conditions et boucles
+
+
+
+
+
+----
+
+## Conditions
+### Définition
+
+Une condition est une **instruction** qui permet d'effectuer une **action** en fonction d'une **condition**.
+
+```java
+int a = 1;
+int b = 2;
+if (a > b) {
+ System.out.println("a est supérieur à b");
+} else {
+ System.out.println("a est inférieur ou égal à b");
+}
+```
+
+> `if` signifie "si" en anglais
+
+----
+
+## Boucles
+### for
+
+Une boucle est une **instruction** qui permet d'effectuer une **action** plusieurs fois.
+
+```java
+for (int i = 0; i < 10; i++) {
+ System.out.println(i);
+}
+```
+
+> Variable `i` : bien ou pas bien ?
+
+Note: Pas bien ! 😱
+
+----
+
+## Boucles
+### for
+
+- Bien que très utilisé, la variable `i` n'est pas très parlante
+- Il est préférable d'utiliser une variable plus parlante
+
+```java
+for (int index = 0; index < 10; index++) {
+ System.out.println(index);
+}
+```
+
+> Ca coute rien et c'est plus clair !
+
+----
+
+## Boucles
+### for : les dérives
+
+- Il est possible de stocker des boucles dans des boucles
+- Les dérives connues consistent à nommer les index `i`, `j`, `k`, `l`, ...
+
+```java
+for (int i = 0; i < 10; i++) {
+ for (int j = 0; j < 10; j++) {
+ for (int k = 0; k < 10; k++) {
+ for (int l = 0; l < 10; l++) {
+ // ...
+ }
+ }
+ }
+}
+```
+
+> Résultat : un code illisible ! 😱
+
+----
+
+## Boucles
+### while
+
+- La boucle `while` permet de répéter une action **tant qu'une condition est vraie**
+- La condition est vérifiée **avant** l'exécution de la boucle
+
+```java
+int i = 0;
+while (i < 10) {
+ System.out.println(i);
+ i++;
+}
+```
+
+> `while` signifie "tant que" en anglais
+
+----
+
+## Boucles
+### do while
+
+- La boucle `do while` permet de répéter une action **tant qu'une condition est vraie**
+- La condition est vérifiée **après** l'exécution de la boucle
+
+```java
+int i = 0;
+do {
+ System.out.println(i);
+ i++;
+} while (i < 10);
+```
+
+---
+
+## Tableaux
+
+
+
+
+
+----
+
+## Tableaux
+### Définition
+
+- Un tableau est une **structure de données** qui permet de stocker plusieurs valeurs.
+- Il a une taille **fixe** et **définie** à l'avance
+- Il est **indexé** à partir de 0
+
+```java
+int[] tableau = new int[10];
+```
+
+> `int[]` est le type du tableau : tableau d'entiers
+
+----
+
+## Tableaux
+### Ajouter des éléments
+
+- Il est possible d'ajouter des éléments dans un tableau
+- Il faut pour cela utiliser l'**index** du tableau
+
+```java
+int[] tableau = new int[10];
+tableau[0] = 1;
+tableau[1] = 2;
+tableau[2] = 3;
+```
+
+> Attention à ne pas dépasser la taille du tableau !
+
+----
+
+## Tableaux
+### Ajouter lors de la création
+
+- Il est possible d'ajouter des éléments lors de la création du tableau
+- Il faut pour cela utiliser des **accolades** et séparer les éléments par des **virgules**
+
+```java
+int[] tableau = new int[] {1, 2, 3};
+```
+
+> Sa taille sera fixée automatiquement !
+
+----
+
+## Tableaux
+### Parcourir un tableau
+
+- Il est possible de parcourir un tableau avec une boucle
+- Il faut pour cela utiliser la **taille** du tableau
+
+```java
+int[] tableau = new int[10];
+for (int index = 0; index < tableau.length; index++) {
+ System.out.println(tableau[index]);
+}
+```
+
+> `tableau.length` permet de récupérer la taille du tableau
+
+----
+
+## Tableaux
+### for-each
+
+- Il est possible de parcourir un tableau avec une boucle `for-each`
+- Il faut pour cela utiliser le mot clé `for` suivi du type de la variable, puis du nom de la variable, puis du tableau
+
+```java
+int[] tableau = new int[10];
+for (int element : tableau) {
+ System.out.println(element);
+}
+```
+
+> Pas de valeur = valeur par défaut du type
+
+----
+
+## Tableaux
+### Agrandir un tableau
+
+- Il est possible d'agrandir un tableau
+- Il faut pour cela créer un nouveau tableau avec la nouvelle taille
+- Il faut ensuite copier les éléments du tableau dans le nouveau tableau
+
+```java
+int[] tableau = {1, 2, 3};
+int[] nouveauTableau = new int[20];
+for (int index = 0; index < tableau.length; index++) {
+ nouveauTableau[index] = tableau[index];
+}
+tableau = nouveauTableau;
+```
+
+----
+
+## Tableaux
+### Tableaux multidimensionnels
+
+- Un tableau peut contenir d'autres tableaux
+- Il s'agit d'un tableau de tableaux
+
+```java
+int[][] tableau = new int[10][10];
+```
+
+> `int[][]` est le type du tableau : tableau de tableaux d'entiers
+
+----
+
+## Tableaux
+### Tableaux multidimensionnels
+
+- On utilisera l'index pour accéder aux éléments
+- Il faut pour cela utiliser l'index du tableau, puis l'index de l'élément
+
+```java
+int[][] tableau = new int[10][10];
+tableau[0][0] = 1;
+tableau[0][1] = 2;
+tableau[0][2] = 3;
+```
+
+> Attention à ne pas dépasser la taille du tableau !
+
+----
+
+## Tableaux
+### ArrayList
+
+- `ArrayList` est une classe qui permet de créer des tableaux dynamiques
+- Il est possible d'ajouter des éléments sans se soucier de la taille
+
+```java
+ArrayList tableau = new ArrayList<>();
+tableau.add(1);
+```
+
+> `ArrayList` est une classe générique, il faut donc préciser le type
+
+----
+
+## Tableaux
+### ArrayList
+
+- `ArrayList` est une implémentation de l'interface `List`
+- Il est possible de récupérer un tableau à partir d'une `List`
+
+```java
+List liste = new ArrayList<>();
+liste.add(1);
+```
+
+```java
+Integer[] tableau = liste.toArray(new Integer[0]);
+```
+
+----
+
+## Integer ?!
+
+- `int` est un type primitif, `Integer` est une classe
+- Comme pour `String`, `Integer` est une classe qui permet de manipuler des `int`
+
+```java
+int a = 1;
+Integer b = 2;
+```
+
+> `Integer` est un **wrapper** de `int`
+
+----
+
+## Tableaux
+### ArrayList
+
+- `List` sert aussi d'interface pour le type `LinkedList`
+- `LinkedList` est une implémentation de `List` qui permet d'ajouter des éléments plus rapidement
+
+```java
+List liste = new LinkedList<>();
+liste.add(1);
+```
+
+> `LinkedList` est une liste chaînée, elle est plus lente à parcourir
+
+---
+
+## Fonctions
+
+
+
+
+
+----
+
+## Fonctions
+### Définition
+
+Une fonction est une **sous-routine** qui permet d'effectuer une **action**.
+
+```java
+public void afficherBonjour() {
+ System.out.println("Bonjour");
+}
+```
+
+> `void` signifie "vide" en anglais
+
+----
+
+## Fonctions
+### Syntaxe
+
+```java
+public () {
+ // Code
+}
+```
+
+- `public` : Visibilité de la fonction
+- `` : Type de retour de la fonction
+- `` : Nom de la fonction
+- `` : Paramètres de la fonction
+- `{}` : Corps de la fonction
+
+----
+
+## Fonctions
+### Visibilité
+
+Il existe plusieurs visibilités pour les fonctions :
+- `public` : Fonction accessible depuis n'importe où
+- `private` : Fonction accessible uniquement depuis la classe
+- `protected` : Fonction accessible depuis la classe et les classes filles
+- `package` : Fonction accessible uniquement depuis le package
+
+> Par défaut, la visibilité est `package`
+
+----
+
+## Fonctions
+### Type de retour
+
+- Dans tous les autres cas, la fonction retourne un type ou `void`
+- `void` : Fonction qui ne retourne rien
+
+```java
+public int addition(int a, int b) {
+ return a + b;
+}
+```
+
+> `return` permet de retourner une valeur
+
+----
+
+## Fonctions
+### Paramètres
+
+Les paramètres sont des variables qui permettent de passer des valeurs à la fonction.
+
+```java
+public void afficherBonjour(String nom) {
+ System.out.println("Bonjour " + nom);
+}
+```
+
+> Les paramètres sont séparés par des virgules
+
+----
+
+## Fonction
+### Appel
+
+Pour appeler une fonction, il faut utiliser son nom suivi des paramètres entre parenthèses.
+
+```java
+afficherBonjour("Alexandre");
+```
+
+> Les paramètres doivent correspondre aux types attendus par la fonction
+
+----
+
+## Fonction
+### Nomenclaure
+
+- Les fonctions doivent être nommées de manière **significative**
+- Elles doivent commencer par un **verbe** à l'infinitif
+- Elles doivent être **courtes** et **concises**
+- On utilisera le **camelCase** pour les nommer
+
+----
+
+## Fonction
+### Bonnes pratiques
+
+- Une fonction doit faire **une seule chose**
+- Une fonction doit faire moins de **20 lignes**
+- Idéalement, une fonction est **documentée** avec de la **JavaDoc**
+
+> Le nom de la fonction est souvent inversement proportionnel à sa taille/complexité
+
+----
+
+## Fonction
+### Exemple
+
+```java
+/**
+ * Affiche un message de bienvenue personnalisé
+ * @param nom Le nom de la personne
+ */
+public void afficherBonjour(String nom) {
+ System.out.println("Bonjour " + nom);
+}
+```
+
+----
+
+## Fonction
+### Découpage
+
+- Une fonction doit faire **une seule chose**
+- Si elle fait plus de 20 lignes, il faut la découper en plusieurs fonctions
+
+```java
+public void afficherBonjour(String nom) {
+ System.out.println("Bonjour " + nom);
+}
+```
+
+> Ici, la fonction ne fait qu'une seule chose, elle est donc bonne !
+
+----
+
+## Fonction
+### Découpage
+
+```java
+/**
+ * Affiche le message de bienvenue et vérifie si la personne est majeure
+ */
+public void afficherBonjourEtVerifierAge(String nom, int age) {
+ System.out.println("Bonjour " + nom);
+ if (age >= 18) {
+ System.out.println("Vous êtes majeur !");
+ } else {
+ System.out.println("Vous êtes mineur !");
+ }
+}
+```
+
+> Ici, la fonction fait deux choses, il faut la découper !
+
+----
+
+## Fonction
+### Découpage
+
+```java
+/**
+ * Affiche le message de bienvenue
+ */
+private void afficherBonjour(String nom) {
+ System.out.println("Bonjour " + nom);
+}
+
+/**
+ * Vérifie si la personne est majeure
+ */
+private void verifierAge(int age) {
+ if (age >= 18) {
+ System.out.println("Vous êtes majeur !");
+ } else {
+ System.out.println("Vous êtes mineur !");
+ }
+}
+
+/**
+ * Affiche le message de bienvenue et vérifie si la personne est majeure
+ */
+public void afficherBonjourEtVerifierAge(String nom, int age) {
+ afficherBonjour(nom);
+ verifierAge(age);
+}
+```
+
+---
+
+## Classes et objets
+
+
+
+
+
+----
+
+## Objets
+### Définition
+
+Un objet est une **instance** d'une **classe**.
+
+```java
+Personne Alex = new Personne();
+```
+
+- `Personne` est le **type** de l'objet
+- `Alex` est le **nom** de l'objet
+
+> `new` permet d'instancier un objet
+
+----
+
+## Classes
+### Définition
+
+Une classe est un **modèle** qui permet de créer des objets.
+
+```java
+public class Personne {
+ // Code
+}
+```
+
+- `public` : Visibilité de la classe
+- `class` : Mot clé pour définir une classe
+- `Personne` : Nom de la classe
+- `{}` : Corps de la classe
+
+----
+
+## Classes
+### Attributs
+
+Les attributs sont des variables qui permettent de stocker des valeurs dans un objet.
+
+```java
+public class Personne {
+ public String nom;
+ public int age;
+}
+```
+
+> Les attributs sont déclarés dans la classe
+
+----
+
+## Classes
+### Méthodes
+
+Les méthodes sont des fonctions qui permettent d'effectuer des actions sur un objet.
+
+```java
+public class Personne {
+ public String nom;
+ public int age;
+
+ public void etudier(String matiere) {
+ System.out.println(nom + " étudie " + matiere);
+ }
+}
+```
+
+----
+
+## Classes
+### Constructeur
+
+Le constructeur est une méthode qui permet d'initialiser un objet.
+
+```java
+public class Personne {
+ public String nom;
+ public int age;
+
+ public Personne(String nom, int age) {
+ this.nom = nom;
+ this.age = age;
+ }
+}
+```
+
+- Il porte le même nom que la classe
+- Appelé lors de l'instanciation
+- Permet d'initialiser les attributs
+
+----
+
+## Classes
+### Précisions
+
+```java
+public class Personne {
+ public String nom;
+ public int age;
+
+ public Personne(String nom, int age) {
+ this.nom = nom;
+ this.age = age;
+ }
+}
+```
+
+- `this` permet de faire référence à l'objet courant
+- `this.nom` fait référence à l'attribut `nom` de l'objet courant
+- `nom` fait référence au paramètre `nom` de la méthode
+
+----
+
+## Classes
+### Statique
+
+- Une classe peut être **statique**
+- Une classe statique ne peut pas être instanciée
+- Elle ne peut contenir que des méthodes statiques
+
+```java
+public static class Personne {
+ // Code
+}
+```
+
+> `static` permet de définir une classe statique
+
+----
+
+## Classes
+### Statique
+
+- L'objectif des classes statique est souvent de regrouper des méthodes
+- Elles sont souvent utilisées pour créer des **utilitaires**
+
+```java
+public static class Mathematiques {
+ public static int addition(int a, int b) {
+ return a + b;
+ }
+}
+```
+
+----
+
+## Classes
+### Attributs statiques
+
+- Attributs qui appartiennent à la classe et non à l'objet
+- Partagés par tous les objets de la classe
+
+```java
+public class Personne {
+ public static int nombreDePersonnes = 0;
+
+ public Personne() {
+ nombreDePersonnes++;
+ }
+}
+```
+Ici, on incrémente le nombre de personnes à chaque fois qu'on instancie un objet
+
+----
+
+## Classes
+### Attributs `final`
+
+- `final` devant un attribut signifie qu'il est **constant**
+- Il ne peut pas être modifié après son initialisation
+- Comme une constante, qui serait initialisée dans le constructeur
+
+```java
+public class Personne {
+ public final String nom;
+
+ public Personne(String nom) {
+ this.nom = nom;
+ }
+}
+```
+
+----
+
+## Classes
+### Classes par défaut
+
+- Il existe de nombreuses classes existantes en Java
+- Elles sont disponibles par défaut dans le langage mais doivent être importées
+- Elles sont regroupées dans des **packages**
+
+```java
+import java.util.ArrayList;
+```
+
+> `import` permet d'importer une classe
+
+----
+
+## Classes
+### Bonnes pratiques
+
+- Une classe doit être **documentée** avec de la **JavaDoc**
+- Elle est **publique** si elle est utilisée par d'autres classes
+- Une classe = un fichier !
+- Elle est nommée en **PascalCase**
+- Elle n'a qu'une seule **responsabilité**
+
+> Nous aborderons ça plus en détail dans les prochains cours !
+
+---
+
+## Packages
+
+
+
+
+
+----
+
+## Packages
+### Définition
+
+- Un package est un **dossier** qui contient des classes
+- Il permet de **regrouper** les classes par **thème**
+- Il permet de **structurer** le code
+
+```java
+package fr.octocorn;
+
+public class Personne {
+ // Code
+}
+```
+
+> `package` permet de définir le package de la classe
+
+----
+
+## Packages
+### Structure
+
+- Les packages sont définis par un **nom de domaine inversé**
+- Il convient d'organiser ses packages en début de projet
+- Il est possible de créer des sous-packages
+
+----
+
+## Packages
+### Structure
+
+```shell
+└───src
+ ├───main
+ │ ├───java
+ │ │ └───fr
+ │ │ └───octocorn
+ │ │ └───cours
+ │ │ └───java
+ │ │ └───Personne.java
+ │ │
+ │ └───resources
+ └───test
+```
+
+> `fr.octocorn.cours.java` est le package de la classe `Personne`
+
+----
+
+## Packages
+### Bonnes pratiques
+
+- Un package par **thème** ou par **fonctionnalité**
+- Un package = un dossier !
+- Il est nommé en **minuscules**
+- Il est nommé en **singulier**
+
+> Il n'y a pas de règles strictes, mais il faut rester cohérent !
+
+----
+
+## Packages
+### Importer
+
+- Il est possible d'importer un package
+- Il faut pour cela utiliser le mot clé `import` suivi du nom du package
+
+```java
+import fr.octocorn.cours.java.Personne;
+
+public class AnimalDeCompagnie {
+ public Personne maitre;
+}
+```
+
+> `import` permet d'importer un package
+
+----
+
+# Demonstration
+
+---
+
+# A vous de jouer !
+
+Réalisez le TP 1 !
+
+Note: `exercices/tp1/tp1.coq.md`
\ No newline at end of file
diff --git a/exercices/TP 1/tp1.coq.md b/exercices/TP 1/tp1.coq.md
new file mode 100644
index 0000000..eb6faca
--- /dev/null
+++ b/exercices/TP 1/tp1.coq.md
@@ -0,0 +1,253 @@
+# TP 1
+
+Vous trouverez ci-dessous différents exercices purement algorithmiques.
+
+Ils ont pour objectif de vous familiariser avec la syntaxe Java, et les bases de la programmation.
+
+Vous créerez un dépot github pour ce TP, et vous y ajouterez vos différents exercices.
+Vous utiliserez la classe `Main` pour tester vos différents exercices et réaliserez une classe par exercice,
+dans un package `tp1.exerciceX` (où X est le numéro de l'exercice).
+
+- Pour tous les exercices, vous gérerez également les exceptions.
+- Par souci de facilité d'utilisation, préférez les méthodes statiques.
+
+> Vous réaliserez un commit par exercice !
+> Si l'exercice peut être réalisé de plusieurs manières, vous réaliserez un commit par version.
+
+---
+
+## Exercice 1 : Calculer la moyenne 📖
+
+Écrivez un programme qui demande à l'utilisateur de saisir 3 notes, puis qui affiche la moyenne de ces notes.
+
+### Contraintes 🚨
+
+- Les notes saisies doivent être des nombres entiers.
+- Les notes saisies doivent être comprises entre 0 et 20.
+- La moyenne doit être un nombre entier.
+- La fonction doit prendre en paramètre un tableau de notes.
+
+### Exemples 🔦
+
+#### Exemple 1
+
+- Note 1 saisie : `10`
+- Note 2 saisie : `10`
+- Note 3 saisie : `10`
+- Moyenne : `10`
+
+#### Exemple 2
+
+- Note 1 saisie : `15`
+- Note 2 saisie : `10`
+- Note 3 saisie : `5`
+- Moyenne : `10`
+
+---
+
+## Exercice 2 : Calculer le prix TTC 📖
+
+Écrivez un programme qui demande à l'utilisateur de saisir un prix HT, puis qui affiche le prix TTC correspondant.
+Le prix TTC est calculé en ajoutant la TVA au prix HT. La TVA est de 20%.
+
+### Contraintes 🚨
+
+- Votre fonction prendra en paramètre un nombre float.
+- Le prix HT saisi doit être un nombre positif.
+- Le prx TTC est un nombre positif float.
+
+### Exemples 🔦
+
+#### Exemple 1
+
+- Prix HT saisi : `100`
+- Prix TTC : `120`
+- Explication : `100 * 1.2 = 120`
+
+#### Exemple 2
+
+- Prix HT saisi : `50`
+- Prix TTC : `60`
+- Explication : `50 * 1.2 = 60`
+
+---
+
+## Exercice 3 : Nombre Palindrome 📖
+
+Un palindrome est un nombre qui peut se lire de la même manière de gauche à droite et de droite à gauche.
+
+> 121 est un palindrome
+
+Écrivez un programme qui permet de déterminer si un nombre saisi par l'utilisateur est un palindrome.
+
+### Contraintes 🚨
+
+- Votre programme retournera `true` si le nombre est un palindrome, `false` sinon.
+- Vous n'avez pas le droit de convertir le nombre en `String`.
+- Le nombre doit être supérieur à 0.
+- Le nombre doit contenir au moins 2 chiffres
+
+### Exemples de résultats attendus 🔦
+
+#### Exemple 1
+
+- Nombre saisi : `121`
+- Résultat : `true`
+- Explication : `121` est un palindrome
+
+#### Exemple 2
+
+- Nombre saisi : `123`
+- Résultat : `false`
+- Explication : `123` n'est pas un palindrome
+
+---
+
+## Exercice 4 : Contient un doublon ? 📖
+
+Écrivez un programme qui permet de déterminer si un tableau d'entiers contient un doublon.
+
+### Contraintes 🚨
+
+- Votre programme retournera `true` si le tableau contient un doublon, `false` sinon.
+
+### Exemples de résultats attendus 🔦
+
+#### Exemple 1
+
+- Tableau saisi : `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`
+- Résultat : `false`
+- Explication : Le tableau ne contient pas de doublon
+
+#### Exemple 2
+
+- Tableau saisi : `[1, 2, 3, 4, 5, 6, 7, 8, 9, 1]`
+- Résultat : `true`
+- Explication : Le tableau contient un doublon avec `1`
+
+### Indices 💡
+
+- Il y a au moins 3 approches possibles :
+ - Utiliser une boucle dans une boucle
+ - Trier le tableau
+ - Utiliser un HashMap
+
+### Aller plus loin 💪
+
+Si vous le souhaitez, vous pouvez essayer de mettre en place les 3 solutions !
+
+---
+
+## Exercice 5 : Nombre romain vers nombre arabe 📖
+
+Écrivez un programme qui permet de calculer la valeur d'un nombre romain saisi par l'utilisateur.
+
+Les valeurs des chiffres romains sont les suivantes :
+
+| Chiffre romain | Valeur |
+|----------------|--------|
+| I | 1 |
+| V | 5 |
+| X | 10 |
+| L | 50 |
+| C | 100 |
+| D | 500 |
+| M | 1000 |
+
+- `I` peut être placé avant `V` et `X` pour faire 4 ou 9.
+- `X` peut être placé avant `L` et `C` pour faire 40 ou 90.
+- `C` peut être placé avant `D` et `M` pour faire 400 ou 900.
+
+### Contraintes 🚨
+
+- L'input ne peut contenir que des chiffres romains.
+- Les chiffres romains ne peuvent aller que de 1 à 3999.
+- La longueur de l'input ne peut excéder 15 caractères.
+- L'input doit contenir au moins un chiffre romain.
+
+### Exemples de résultats attendus 🔦
+
+#### Exemple 1
+
+- Nombre saisi : `X`
+- Résultat : `10`
+- Explication : `X` vaut `10`
+
+#### Exemple 2
+
+- Nombre saisi : `LVIII`
+- Résultat : `58`
+- Explication : `L` = `50`, `V` = `5`, `III` = `3`
+
+#### Exemple 3
+
+- Nombre saisi : `MCMXCII`
+- Résultat : `1992`
+- Explication : `M` = `1000`, `CM` = `900`, `XC` = `90`, `II` = `2`
+
+### Indices 💡
+
+2 méthodes :
+- Imbriquer des `if` et des `else if` pour chaque cas particulier.
+- Utiliser un `HashMap`
+
+### Aller plus loin 💪
+
+- Essayez de réaliser les deux méthodes !
+
+---
+
+## Exercice 6 : Element majorité 📖
+
+Écrivez un programme qui permet d'indiquer le nombre majoritaire dans un tableau d'entiers.
+Partez du principe qu'il y a forcément au moins un élément majoritaire.
+
+> ❗Comme pour élire un président de la république, il faut avoir plus de 50% des voix pour être élu !
+
+
+### Contraintes 🚨
+
+- Votre programme retournera l'élément le plus présent dans le tableau.
+- La fonction prendra en paramètre un tableau d'entiers.
+- Le tableau peut comprendre des nombres entre -10^9 et 5 * 10^4.
+- La longueur du tableau peut aller de 1 à 50000.
+
+### Exemples de résultats attendus 🔦
+
+#### Exemple 1
+
+- Tableau saisi : `[3, 2, 3]`
+- Résultat : `3`
+- Explication : Chaque élément n'est présent qu'une seule fois. 1 est le premier élément trouvé.
+
+#### Exemple 2
+
+- Tableau saisi : `[2, 2, 1, 1, 1, 2, 2]`
+- Résultat : `1`
+- Explication : 1 est le seul à être présent deux fois.
+
+#### Exemple 3
+
+- Tableau saisi : `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`
+- Résultat : `5`
+- Explication : Il n'y a pas d'élément majoritaire, mais 5 est l'élément du milieu
+
+#### Exemple 4
+
+- Tableau saisi : `[1, 1, 1, 2, 2, 3, 4, 5, 5]`
+- Résultat : `2`
+- Explication : Il n'y a pas d'élément majoritaire ici, l'input est donc mauvais !
+
+### Indices 💡
+
+Il y a au moins 2 manières de résoudre cet exercice :
+- Trier le tableau
+- Utiliser un HashMap
+
+### Aller plus loin 💪
+
+- Essayez d'utiliser les 2 méthodes !
+
+#### BONUS : Méthode Boyer-Moore
+
+Essayez de résoudre ce problème avec l'algorithme de [Boyer-Moore](https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_majority_vote_algorithm)
diff --git a/exercices/TP 1/tp1.poulet.md b/exercices/TP 1/tp1.poulet.md
new file mode 100644
index 0000000..e340594
--- /dev/null
+++ b/exercices/TP 1/tp1.poulet.md
@@ -0,0 +1,276 @@
+# TP 1
+
+Vous trouverez ci-dessous différents exercices purement algorithmiques.
+
+Ils ont pour objectif de vous familiariser avec la syntaxe Java, et les bases de la programmation.
+
+Vous créerez un dépot github pour ce TP, et vous y ajouterez vos différents exercices.
+Vous utiliserez la classe `Main` pour tester vos différents exercices et réaliserez une classe par exercice,
+dans un package `tp1.exerciceX` (où X est le numéro de l'exercice).
+
+- Pour tous les exercices, vous gérerez également les exceptions.
+- Par souci de facilité d'utilisation, préférez les méthodes statiques.
+
+> Vous réaliserez un commit par exercice !
+> Si l'exercice peut être réalisé de plusieurs manières, vous réaliserez un commit par version.
+
+---
+
+## Exercice 1 : Calculer la moyenne 📖
+
+Écrivez un programme qui demande à l'utilisateur de saisir 3 notes, puis qui affiche la moyenne de ces notes.
+
+### Contraintes 🚨
+
+- Les notes saisies doivent être des nombres entiers.
+- Les notes saisies doivent être comprises entre 0 et 20.
+- La moyenne doit être un nombre entier.
+- La fonction doit prendre en paramètre un tableau de notes.
+
+### Exemples 🔦
+
+#### Exemple 1
+
+- Note 1 saisie : `10`
+- Note 2 saisie : `10`
+- Note 3 saisie : `10`
+- Moyenne : `10`
+
+#### Exemple 2
+
+- Note 1 saisie : `15`
+- Note 2 saisie : `10`
+- Note 3 saisie : `5`
+- Moyenne : `10`
+
+### Indices 💡
+
+- Vous pouvez lever une exception avec `throw new IllegalArgumentException("Message d'erreur");`
+- Vous devrez vérifier que la note est bien comprise entre 0 et 20.
+
+---
+
+## Exercice 2 : Calculer le prix TTC 📖
+
+Écrivez un programme qui demande à l'utilisateur de saisir un prix HT, puis qui affiche le prix TTC correspondant.
+Le prix TTC est calculé en ajoutant la TVA au prix HT. La TVA est de 20%.
+
+### Contraintes 🚨
+
+- Votre fonction prendra en paramètre un nombre float.
+- Le prix HT saisi doit être un nombre positif.
+- Le prx TTC est un nombre positif float.
+
+### Exemples 🔦
+
+#### Exemple 1
+
+- Prix HT saisi : `100`
+- Prix TTC : `120`
+- Explication : `100 * 1.2 = 120`
+
+#### Exemple 2
+
+- Prix HT saisi : `50`
+- Prix TTC : `60`
+- Explication : `50 * 1.2 = 60`
+
+### Indices 💡
+
+- Il suffit de multiplier le prix HT par 1.2 pour obtenir le prix TTC
+
+---
+
+## Exercice 3 : Nombre Palindrome 📖
+
+Un palindrome est un nombre qui peut se lire de la même manière de gauche à droite et de droite à gauche.
+
+> 121 est un palindrome
+
+Écrivez un programme qui permet de déterminer si un nombre saisi par l'utilisateur est un palindrome.
+
+### Contraintes 🚨
+
+- Votre programme retournera `true` si le nombre est un palindrome, `false` sinon.
+- Vous n'avez pas le droit de convertir le nombre en `String`.
+- Le nombre doit être supérieur à 0.
+- Le nombre doit contenir au moins 2 chiffres
+
+### Exemples de résultats attendus 🔦
+
+#### Exemple 1
+
+- Nombre saisi : `121`
+- Résultat : `true`
+- Explication : `121` est un palindrome
+
+#### Exemple 2
+
+- Nombre saisi : `123`
+- Résultat : `false`
+- Explication : `123` n'est pas un palindrome
+
+### Indices 💡
+
+- Vous devrez trouver le moyen de renverser le nombre saisi par l'utilisateur.
+- Il vous suffira ensuite de comparer les deux nombres
+
+> 💡 L'opérateur `%` permet de récupérer le reste d'une division euclidienne (modulo)
+
+---
+
+## Exercice 4 : Contient un doublon ? 📖
+
+Écrivez un programme qui permet de déterminer si un tableau d'entiers contient un doublon.
+
+### Contraintes 🚨
+
+- Votre programme retournera `true` si le tableau contient un doublon, `false` sinon.
+
+### Exemples de résultats attendus 🔦
+
+#### Exemple 1
+
+- Tableau saisi : `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`
+- Résultat : `false`
+- Explication : Le tableau ne contient pas de doublon
+
+#### Exemple 2
+
+- Tableau saisi : `[1, 2, 3, 4, 5, 6, 7, 8, 9, 1]`
+- Résultat : `true`
+- Explication : Le tableau contient un doublon avec `1`
+
+### Indices 💡
+
+Il y a au moins 3 approches possibles :
+- Utiliser une boucle dans une boucle
+- Trier le tableau et comparer chaque élément avec le suivant
+- Utiliser un HashMap et compter les occurrences
+
+
+### Aller plus loin 💪
+
+Si vous le souhaitez, vous pouvez essayer de mettre en place les 3 solutions !
+
+---
+
+## Exercice 5 : Nombre romain vers nombre arabe 📖
+
+Écrivez un programme qui permet de calculer la valeur d'un nombre romain saisi par l'utilisateur.
+
+Les valeurs des chiffres romains sont les suivantes :
+
+| Chiffre romain | Valeur |
+|----------------|--------|
+| I | 1 |
+| V | 5 |
+| X | 10 |
+| L | 50 |
+| C | 100 |
+| D | 500 |
+| M | 1000 |
+
+- `I` peut être placé avant `V` et `X` pour faire 4 ou 9.
+- `X` peut être placé avant `L` et `C` pour faire 40 ou 90.
+- `C` peut être placé avant `D` et `M` pour faire 400 ou 900.
+
+### Contraintes 🚨
+
+- L'input ne peut contenir que des chiffres romains.
+- Les chiffres romains ne peuvent aller que de 1 à 3999.
+- La longueur de l'input ne peut excéder 15 caractères.
+- L'input doit contenir au moins un chiffre romain.
+
+### Exemples de résultats attendus 🔦
+
+#### Exemple 1
+
+- Nombre saisi : `X`
+- Résultat : `10`
+- Explication : `X` vaut `10`
+
+#### Exemple 2
+
+- Nombre saisi : `LVIII`
+- Résultat : `58`
+- Explication : `L` = `50`, `V` = `5`, `III` = `3`
+
+#### Exemple 3
+
+- Nombre saisi : `MCMXCII`
+- Résultat : `1992`
+- Explication : `M` = `1000`, `CM` = `900`, `XC` = `90`, `II` = `2`
+
+### Indices 💡
+
+2 méthodes
+- La manière la plus simple serait d'imbriquer des `if` et des `else if` pour chaque cas particulier.
+- L'autre méthode consiste à utiliser un `HashMap`
+
+> 💡 Pensez à vérifier si le nombre n'est pas comptabilisé deux fois ! (par exemple, `IV` est comptabilisé comme `1` et `5`)
+
+### Aller plus loin 💪
+
+- Essayez de réaliser les deux méthodes `HashMap` !
+
+---
+
+## Exercice 6 : Element majorité 📖
+
+Écrivez un programme qui permet d'indiquer le nombre majoritaire dans un tableau d'entiers.
+Partez du principe qu'il y a forcément au moins un élément majoritaire.
+
+> ❗Comme pour élire un président de la république, il faut avoir plus de 50% des voix pour être élu !
+
+
+### Contraintes 🚨
+
+- Votre programme retournera l'élément le plus présent dans le tableau.
+- La fonction prendra en paramètre un tableau d'entiers.
+- Le tableau peut comprendre des nombres entre -10^9 et 5 * 10^4.
+- La longueur du tableau peut aller de 1 à 50000.
+
+### Exemples de résultats attendus 🔦
+
+#### Exemple 1
+
+- Tableau saisi : `[3, 2, 3]`
+- Résultat : `3`
+- Explication : Chaque élément n'est présent qu'une seule fois. 1 est le premier élément trouvé.
+
+#### Exemple 2
+
+- Tableau saisi : `[2, 2, 1, 1, 1, 2, 2]`
+- Résultat : `1`
+- Explication : 1 est le seul à être présent deux fois.
+
+#### Exemple 3
+
+- Tableau saisi : `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`
+- Résultat : `5`
+- Explication : Il n'y a pas d'élément majoritaire, mais 5 est l'élément du milieu
+
+#### Exemple 4
+
+- Tableau saisi : `[1, 1, 1, 2, 2, 3, 4, 5, 5]`
+- Résultat : `2`
+- Explication : Il n'y a pas d'élément majoritaire ici, l'input est donc mauvais !
+
+### Indices 💡
+
+Il y a au moins 2 manières de résoudre cet exercice :
+- Trier le tableau
+ - Un élément majoritaire est sera forcément présent plus de `n/2` fois, où `n` est la longueur du tableau.
+ - Problème : si aucun élément n'est majoritaire, on retourne l'élément du milieu, qui n'est pas forcément majoritaire !
+- Utiliser un HashMap
+ - `getOrDefault` de la classe `HashMap` permet de récupérer une valeur, ou une valeur par défaut si la clé n'existe pas
+ - `entrySet` de la classe `HashMap` permet de parcourir un `HashMap` avec une boucle `for`
+
+### Aller plus loin 💪
+
+- Essayez d'utiliser les 2 méthodes !
+
+#### BONUS
+
+Essayez de résoudre ce problème avec l'algorithme de [Boyer-Moore](https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_majority_vote_algorithm)
diff --git a/exercices/TP 1/tp1.poussin.md b/exercices/TP 1/tp1.poussin.md
new file mode 100644
index 0000000..473eabd
--- /dev/null
+++ b/exercices/TP 1/tp1.poussin.md
@@ -0,0 +1,301 @@
+# TP 1
+
+Vous trouverez ci-dessous différents exercices purement algorithmiques.
+
+Ils ont pour objectif de vous familiariser avec la syntaxe Java, et les bases de la programmation.
+
+Vous créerez un dépot github pour ce TP, et vous y ajouterez vos différents exercices.
+Vous utiliserez la classe `Main` pour tester vos différents exercices et réaliserez une classe par exercice,
+dans un package `tp1.exerciceX` (où X est le numéro de l'exercice).
+
+- Pour tous les exercices, vous gérerez également les exceptions.
+- Par souci de facilité d'utilisation, préférez les méthodes statiques.
+
+> Vous réaliserez un commit par exercice !
+> Si l'exercice peut être réalisé de plusieurs manières, vous réaliserez un commit par version.
+
+---
+
+## Exercice 1 : Calculer la moyenne 📖
+
+Écrivez un programme qui demande à l'utilisateur de saisir 3 notes, puis qui affiche la moyenne de ces notes.
+
+### Contraintes 🚨
+
+- Les notes saisies doivent être des nombres entiers.
+- Les notes saisies doivent être comprises entre 0 et 20.
+- La moyenne doit être un nombre entier.
+- La fonction doit prendre en paramètre un tableau de notes.
+
+### Exemples 🔦
+
+#### Exemple 1
+
+- Note 1 saisie : `10`
+- Note 2 saisie : `10`
+- Note 3 saisie : `10`
+- Moyenne : `10`
+
+#### Exemple 2
+
+- Note 1 saisie : `15`
+- Note 2 saisie : `10`
+- Note 3 saisie : `5`
+- Moyenne : `10`
+
+### Indices 💡
+
+- Vous pouvez lever une exception avec `throw new IllegalArgumentException("Message d'erreur");`
+- Vous devrez vérifier la longueur du tableau de notes avec `notes.length`
+- Vous devrez vérifier que la note est bien comprise entre 0 et 20 avec `note >= 0 && note <= 20`
+- Vous devrez additionner tous les éléments du tableau avec une boucle `for` et une variable `somme` et les diviser par la longueur du tableau avec `somme / notes.length`
+
+---
+
+## Exercice 2 : Calculer le prix TTC 📖
+
+Écrivez un programme qui demande à l'utilisateur de saisir un prix HT, puis qui affiche le prix TTC correspondant.
+Le prix TTC est calculé en ajoutant la TVA au prix HT. La TVA est de 20%.
+
+### Contraintes 🚨
+
+- Votre fonction prendra en paramètre un nombre float.
+- Le prix HT saisi doit être un nombre positif.
+- Le prx TTC est un nombre positif float.
+
+### Exemples 🔦
+
+#### Exemple 1
+
+- Prix HT saisi : `100`
+- Prix TTC : `120`
+- Explication : `100 * 1.2 = 120`
+
+#### Exemple 2
+
+- Prix HT saisi : `50`
+- Prix TTC : `60`
+- Explication : `50 * 1.2 = 60`
+
+### Indices 💡
+
+- Vous pouvez lever une exception avec `throw new IllegalArgumentException("Message d'erreur");`
+- Il suffit de multiplier le prix HT par 1.2 pour obtenir le prix TTC
+
+---
+
+## Exercice 3 : Nombre Palindrome 📖
+
+Un palindrome est un nombre qui peut se lire de la même manière de gauche à droite et de droite à gauche.
+
+> 121 est un palindrome
+
+Écrivez un programme qui permet de déterminer si un nombre saisi par l'utilisateur est un palindrome.
+
+### Contraintes 🚨
+
+- Votre programme retournera `true` si le nombre est un palindrome, `false` sinon.
+- Vous n'avez pas le droit de convertir le nombre en `String`.
+- Le nombre doit être supérieur à 0.
+- Le nombre doit contenir au moins 2 chiffres
+
+### Exemples de résultats attendus 🔦
+
+#### Exemple 1
+
+- Nombre saisi : `121`
+- Résultat : `true`
+- Explication : `121` est un palindrome
+
+#### Exemple 2
+
+- Nombre saisi : `123`
+- Résultat : `false`
+- Explication : `123` n'est pas un palindrome
+
+### Indices 💡
+
+- Vous devrez trouver le moyen de renverser le nombre saisi par l'utilisateur.
+- Il suffira ensuite de comparer les deux nombres
+- Vous aurez besoin d'une boule pour parcourir le nombre et le renverser
+- Vous pouvez utiliser l'opérateur `% 10` pour récupérer le dernier chiffre d'un nombre
+
+> 💡 L'opérateur `%` permet de récupérer le reste d'une division euclidienne (modulo)
+
+---
+
+## Exercice 4 : Contient un doublon ? 📖
+
+Écrivez un programme qui permet de déterminer si un tableau d'entiers contient un doublon.
+
+### Contraintes 🚨
+
+- Votre programme retournera `true` si le tableau contient un doublon, `false` sinon.
+
+### Exemples de résultats attendus 🔦
+
+#### Exemple 1
+
+- Tableau saisi : `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`
+- Résultat : `false`
+- Explication : Le tableau ne contient pas de doublon
+
+#### Exemple 2
+
+- Tableau saisi : `[1, 2, 3, 4, 5, 6, 7, 8, 9, 1]`
+- Résultat : `true`
+- Explication : Le tableau contient un doublon avec `1`
+
+### Indices 💡
+
+- Il y a au moins 3 approches possibles :
+ - Utiliser une boucle dans une boucle pour comparer chaque élément avec tous les autres
+ - Option plus simple à mettre en place, mais très lourde en terme de performance
+ - Trier le tableau et comparer chaque élément avec le suivant
+ - En utilisant la méthode `Arrays.sort(tableau)` de la classe `Arrays`
+ - Relativement simple et assez efficace
+ - Utiliser un HashMap pour compter le nombre d'occurrences de chaque élément
+ - En utilisant la classe `HashMap` de Java
+ - Plus complexe à mettre en place, mais très efficace
+
+> 💡 Vous pouvez `return` dès que vous trouvez un doublon !
+
+
+### Aller plus loin 💪
+
+Si vous le souhaitez, vous pouvez essayer de mettre en place les 3 solutions !
+
+---
+
+## Exercice 5 : Nombre romain vers nombre arabe 📖
+
+Écrivez un programme qui permet de calculer la valeur d'un nombre romain saisi par l'utilisateur.
+
+Les valeurs des chiffres romains sont les suivantes :
+
+| Chiffre romain | Valeur |
+|----------------|--------|
+| I | 1 |
+| V | 5 |
+| X | 10 |
+| L | 50 |
+| C | 100 |
+| D | 500 |
+| M | 1000 |
+
+- `I` peut être placé avant `V` et `X` pour faire 4 ou 9.
+- `X` peut être placé avant `L` et `C` pour faire 40 ou 90.
+- `C` peut être placé avant `D` et `M` pour faire 400 ou 900.
+
+### Contraintes 🚨
+
+- L'input ne peut contenir que des chiffres romains.
+- Les chiffres romains ne peuvent aller que de 1 à 3999.
+- La longueur de l'input ne peut excéder 15 caractères.
+- L'input doit contenir au moins un chiffre romain.
+
+### Exemples de résultats attendus 🔦
+
+#### Exemple 1
+
+- Nombre saisi : `X`
+- Résultat : `10`
+- Explication : `X` vaut `10`
+
+#### Exemple 2
+
+- Nombre saisi : `LVIII`
+- Résultat : `58`
+- Explication : `L` = `50`, `V` = `5`, `III` = `3`
+
+#### Exemple 3
+
+- Nombre saisi : `MCMXCII`
+- Résultat : `1992`
+- Explication : `M` = `1000`, `CM` = `900`, `XC` = `90`, `II` = `2`
+
+### Indices 💡
+
+2 méthodes
+- La manière la plus simple serait d'imbriquer des `if` et des `else if` pour chaque cas particulier.
+ - On peut s'abord vérifier le caractère en question, et si le caractère précédent est un `I`, `X` ou `C` et le soustraire au nombre arabe.
+ - Vous pouvez obtenir le caractère à un index donné avec la méthode `charAt(index)` de la classe `String`.
+- L'autre méthode consiste à utiliser un `HashMap`
+ - Vous pouvez créer un `HashMap` avec `Map nombresRomains = new HashMap<>();`
+ - Vous pouvez ajouter des valeurs avec `nombresRomains.put('I', 1);`
+ - Vous pouvez récupérer une valeur avec `nombresRomains.get('I');`, ce qui vous renverra `1`
+
+> 💡Attention à bien vérifier que le caractère précédent existe bien avant de le comparer !
+
+> 💡 Pensez à vérifier si le nombre n'est pas comptabilisé deux fois ! (par exemple, `IV` est comptabilisé comme `1` et `5`)
+
+### Aller plus loin 💪
+
+- Essayez de réaliser les deux méthodes `HashMap` !
+
+---
+
+## Exercice 6 : Element majorité 📖
+
+Écrivez un programme qui permet d'indiquer le nombre majoritaire dans un tableau d'entiers.
+Partez du principe qu'il y a forcément au moins un élément majoritaire.
+
+> ❗Comme pour élire un président de la république, il faut avoir plus de 50% des voix pour être élu !
+
+
+### Contraintes 🚨
+
+- Votre programme retournera l'élément le plus présent dans le tableau.
+- La fonction prendra en paramètre un tableau d'entiers.
+- Le tableau peut comprendre des nombres entre -10^9 et 5 * 10^4.
+- La longueur du tableau peut aller de 1 à 50000.
+
+### Exemples de résultats attendus 🔦
+
+#### Exemple 1
+
+- Tableau saisi : `[3, 2, 3]`
+- Résultat : `3`
+- Explication : Chaque élément n'est présent qu'une seule fois. 1 est le premier élément trouvé.
+
+#### Exemple 2
+
+- Tableau saisi : `[2, 2, 1, 1, 1, 2, 2]`
+- Résultat : `1`
+- Explication : 1 est le seul à être présent deux fois.
+
+#### Exemple 3
+
+- Tableau saisi : `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`
+- Résultat : `5`
+- Explication : Il n'y a pas d'élément majoritaire, mais 5 est l'élément du milieu
+
+#### Exemple 4
+
+- Tableau saisi : `[1, 1, 1, 2, 2, 3, 4, 5, 5]`
+- Résultat : `2`
+- Explication : Il n'y a pas d'élément majoritaire ici, l'input est donc mauvais !
+
+### Indices 💡
+
+Il y a au moins 2 manières de résoudre cet exercice :
+- Trier le tableau
+ - Un élément majoritaire est sera forcément présent plus de `n/2` fois, où `n` est la longueur du tableau.
+ - Sur un tableau de 10 éléments, l'élément majoritaire sera présent au moins 6 fois.
+ - Si le tableau est trié, il sera forcément au milieu !
+ - Problème : si aucun élément n'est majoritaire, on retourne l'élément du milieu, qui n'est pas forcément majoritaire !
+- Utiliser un HashMap
+ - On peut compter le nombre d'occurrences de chaque élément dans le tableau
+ - On peut ensuite récupérer l'élément avec le plus d'occurrences
+ - Et extraire celui qui sera présent plus de `n/2` fois
+ - Retourner cet élément, ou 0 si aucun élément n'est majoritaire
+ - La méthode `getOrDefault` de la classe `HashMap` permet de récupérer une valeur, ou une valeur par défaut si la clé n'existe pas
+ - La méthode `entrySet` de la classe `HashMap` permet de récupérer un `Set` de `Map.Entry`, ce qui permet de parcourir un `HashMap` avec une boucle `for`
+
+### Aller plus loin 💪
+
+- Essayez d'utiliser les 2 méthodes !
+
+#### BONUS
+
+Essayez de résoudre ce problème avec l'algorithme de [Boyer-Moore](https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_majority_vote_algorithm)