Styling

Author: fpluquet

docs/cours/design-patterns/1-intro.md

@@ -2,20 +2,22 @@
 
 En génie logiciel, un **design pattern** (ou patron de conception) est une solution générale, éprouvée et réutilisable à un problème récurrent dans la conception de logiciels orientés objet.
 
-> **Info :**
-> Un design pattern n'est pas un code prêt à l'emploi, mais une sorte de « recette » ou de modèle de solution, applicable dans de nombreux contextes. Il décrit :
-> - le problème à résoudre,
-> - la solution générique,
-> - les conséquences de son utilisation.
+::: info
+Un design pattern n'est pas un code prêt à l'emploi, mais une sorte de « recette » ou de modèle de solution, applicable dans de nombreux contextes. Il décrit :
+- le problème à résoudre,
+- la solution générique,
+- les conséquences de son utilisation.
+:::
 
 ## Pourquoi utiliser les design patterns ?
 - **Réutilisabilité** : On évite de réinventer la roue.
 - **Lisibilité** : Les développeurs comprennent plus vite le rôle d'une structure connue.
 - **Robustesse** : Les patterns sont éprouvés et testés.
 - **Communication** : Ils fournissent un vocabulaire commun entre développeurs.
 
-> **À retenir :**
-> Les design patterns facilitent la maintenance, la compréhension et l'évolution des logiciels.
+::: tip
+À retenir : Les design patterns facilitent la maintenance, la compréhension et l'évolution des logiciels.
+:::
 
 ## Origine
 Les design patterns ont été popularisés par le livre "Design Patterns: Elements of Reusable Object-Oriented Software" (1994) par Erich Gamma, Richard Helm, Ralph Johnson et John Vlissides (le "Gang of Four" ou GoF).
@@ -28,8 +30,9 @@ Un pattern est généralement décrit par :
 - **Conséquences**
 - **Exemple d'implémentation**
 
-> **Info :**
-> Apprenez à reconnaître les patterns dans le code existant, cela vous aidera à mieux comprendre et à améliorer des projets complexes.
+::: info
+Apprenez à reconnaître les patterns dans le code existant, cela vous aidera à mieux comprendre et à améliorer des projets complexes.
+:::
 
 ## Exemples de design patterns célèbres
 - Singleton

docs/cours/design-patterns/2-categories.md

@@ -2,44 +2,46 @@
 
 Les design patterns sont classés en trois grandes familles, chacune répondant à des besoins spécifiques dans la conception logicielle.
 
-> **Info :**
-> Comprendre à quelle famille appartient un pattern aide à choisir la bonne solution selon le problème rencontré.
+::: info
+Comprendre à quelle famille appartient un pattern aide à choisir la bonne solution selon le problème rencontré.
+:::
 
 ## 1. Patterns de création (Creational Patterns)
 Ils concernent la manière de créer des objets, en masquant la logique de création et en rendant le système indépendant de la façon dont ses objets sont créés, composés et représentés.
 
 **Exemples :**
-- **Singleton** : Garantit une seule instance d'une classe.
-- **Factory Method** : Délègue la création d'objets à des sous-classes.
-- **Abstract Factory** : Crée des familles d'objets liés.
-- **Builder** : Construit des objets complexes étape par étape.
-- **Prototype** : Clone des objets existants.
+- [**Singleton**](3-creational.md#singleton) : Garantit une seule instance d'une classe.
+- [**Factory Method**](3-creational.md#factory-method) : Délègue la création d'objets à des sous-classes.
+- [**Abstract Factory**](3-creational.md#abstract-factory) : Crée des familles d'objets liés.
+- [**Builder**](3-creational.md#builder) : Construit des objets complexes étape par étape.
+- [**Prototype**](3-creational.md#prototype) : Clone des objets existants.
 
 ## 2. Patterns structurels (Structural Patterns)
 Ils concernent la composition des classes et des objets, facilitant la conception de structures flexibles et efficaces.
 
 **Exemples :**
-- **Adapter** : Rend compatibles des interfaces différentes.
-- **Bridge** : Sépare abstraction et implémentation.
-- **Composite** : Structure des objets en arbre.
-- **Decorator** : Ajoute dynamiquement des fonctionnalités.
-- **Facade** : Simplifie l'accès à un sous-système complexe.
-- **Flyweight** : Partage des objets pour économiser de la mémoire.
-- **Proxy** : Contrôle l'accès à un objet.
+- [**Adapter**](4-structural.md#adapter) : Rend compatibles des interfaces différentes.
+- [**Bridge**](4-structural.md#bridge) : Sépare abstraction et implémentation.
+- [**Composite**](4-structural.md#composite) : Structure des objets en arbre.
+- [**Decorator**](4-structural.md#decorator) : Ajoute dynamiquement des fonctionnalités.
+- [**Facade**](4-structural.md#facade) : Simplifie l'accès à un sous-système complexe.
+- [**Flyweight**](4-structural.md#flyweight) : Partage des objets pour économiser de la mémoire.
+- [**Proxy**](4-structural.md#proxy) : Contrôle l'accès à un objet.
 
 ## 3. Patterns comportementaux (Behavioral Patterns)
 Ils concernent la communication et la répartition des responsabilités entre les objets.
 
 **Exemples :**
-- **Observer** : Notifie automatiquement les changements d'état.
-- **Strategy** : Permute dynamiquement des algorithmes.
-- **Command** : Encapsule des requêtes comme objets.
-- **State** : Change le comportement selon l'état interne.
-- **Chain of Responsibility** : Passe une requête à travers une chaîne d'objets.
-- **Iterator** : Parcourt une collection sans exposer sa structure.
-- **Mediator, Memento, Template Method, Visitor, Interpreter** : Autres patterns avancés.
-
-> **À retenir :**
-> Chaque famille répond à une problématique différente : création, structure ou comportement.
+- [**Observer**](5-behavioral.md#observer) : Notifie automatiquement les changements d'état.
+- [**Strategy**](5-behavioral.md#strategy) : Permute dynamiquement des algorithmes.
+- [**Command**](5-behavioral.md#command) : Encapsule des requêtes comme objets.
+- [**State**](5-behavioral.md#state) : Change le comportement selon l'état interne.
+- [**Chain of Responsibility**](5-behavioral.md#chain-of-responsibility) : Passe une requête à travers une chaîne d'objets.
+- [**Iterator**](5-behavioral.md#iterator) : Parcourt une collection sans exposer sa structure.
+- [**Mediator**](5-behavioral.md#mediator), [**Memento**](5-behavioral.md#memento), [**Template Method**](5-behavioral.md#template-method), [**Visitor**](5-behavioral.md#visitor), [**Interpreter**](5-behavioral.md#interpreter) : Autres patterns avancés.
+
+::: tip
+À retenir : Chaque famille répond à une problématique différente : création, structure ou comportement.
+:::
 
 Chacune de ces familles sera détaillée dans les fichiers suivants, avec des exemples concrets en Java.

docs/cours/design-patterns/3-creational.md

@@ -2,8 +2,9 @@
 
 Les patterns de création facilitent la création d'objets tout en cachant la logique de création. Ils permettent de rendre le code plus flexible, testable et indépendant des classes concrètes.
 
-> **Info :**
-> Utilisez ces patterns pour éviter le couplage fort entre les classes et la logique de création d'objets.
+::: info
+Utilisez ces patterns pour éviter le couplage fort entre les classes et la logique de création d'objets.
+:::
 
 ## Singleton
 Le Singleton garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global à cette instance.
@@ -54,8 +55,9 @@ public class Database {
 }
 ```
 
-> **À retenir :**
-> Le constructeur est privé pour empêcher la création d'autres instances.
+::: warning
+Le constructeur est privé pour empêcher la création d'autres instances.
+:::
 
 ## Factory Method
 Permet de déléguer la création d'objets à des sous-classes, sans connaître la classe exacte à instancier.
@@ -243,7 +245,8 @@ Sheep s1 = new Sheep();
 Sheep s2 = s1.clone();
 ```
 
-> **Info :**
-> Le pattern Prototype est utile pour dupliquer rapidement des objets configurés.
+::: info
+Le pattern Prototype est utile pour dupliquer rapidement des objets configurés.
+:::
 
 Chaque pattern de création permet de résoudre des problèmes spécifiques liés à l'instanciation d'objets, tout en rendant le code plus flexible et maintenable.

docs/cours/design-patterns/4-structural.md

@@ -2,8 +2,9 @@
 
 Les patterns structurels facilitent la composition de classes et d'objets pour former des structures plus complexes. Ils permettent de rendre les architectures plus flexibles, évolutives et maintenables.
 
-> **Info :**
-> Utilisez ces patterns pour organiser et optimiser la structure de vos applications, sans modifier le code existant.
+::: info
+Utilisez ces patterns pour organiser et optimiser la structure de vos applications, sans modifier le code existant.
+:::
 
 ## Adapter
 Permet de faire collaborer des classes qui n'ont pas d'interface compatible.
@@ -51,8 +52,9 @@ class Adaptateur implements Cible {
 }
 ```
 
-> **À retenir :**
-> L'adaptateur agit comme un traducteur entre deux interfaces incompatibles.
+::: tip
+À retenir : L'adaptateur agit comme un traducteur entre deux interfaces incompatibles.
+:::
 
 ## Bridge
 Sépare l'abstraction de son implémentation pour qu'elles puissent évoluer indépendamment.
@@ -148,8 +150,9 @@ class Composite implements Composant {
 }
 ```
 
-> **Info :**
-> Le composite est très utilisé pour les structures arborescentes (ex : menus, systèmes de fichiers).
+::: info
+Le composite est très utilisé pour les structures arborescentes (ex : menus, systèmes de fichiers).
+:::
 
 ## Decorator
 Ajoute dynamiquement des responsabilités à un objet.
@@ -307,5 +310,6 @@ class ProxyService implements Service {
 }
 ```
 
-> **À retenir :**
-> Les patterns structurels facilitent la maintenance et l'évolution des architectures logicielles.
+::: tip
+À retenir : Les patterns structurels facilitent la maintenance et l'évolution des architectures logicielles.
+:::

docs/cours/design-patterns/5-behavioral.md

@@ -2,8 +2,9 @@
 
 Les patterns comportementaux facilitent la communication entre objets et la répartition des responsabilités. Ils permettent de rendre les interactions plus souples, découplées et évolutives.
 
-> **Info :**
-> Utilisez ces patterns pour organiser la logique métier et la communication entre objets sans créer de dépendances fortes.
+::: info
+Utilisez ces patterns pour organiser la logique métier et la communication entre objets sans créer de dépendances fortes.
+:::
 
 ## Observer
 Le pattern Observer permet à un objet (le sujet) de notifier automatiquement ses observateurs lorsqu'un changement d'état survient. Cela permet de mettre en place des systèmes réactifs et découplés.
@@ -64,8 +65,9 @@ sujet.ajouter(o);
 sujet.changerEtat("Nouveau!");
 ```
 
-> **À retenir :**
-> L'observateur permet de réagir automatiquement à des changements sans couplage fort.
+::: tip
+À retenir : L'observateur permet de réagir automatiquement à des changements sans couplage fort.
+:::
 
 ## Strategy
 Permet de changer dynamiquement l'algorithme utilisé par un objet.
@@ -680,10 +682,12 @@ sequenceDiagram
 
 On voit ici que l'action est déterminée par le type de l'objet et le type de l'interaction, permettant ainsi un comportement flexible et extensible.
 
-> **À retenir :**
-> Le double dispatch permet de gérer des interactions complexes entre types, en déléguant la logique de décision à des classes spécifiques. Cela rend le code plus flexible et extensible, car on peut ajouter de nouveaux types d'interactions sans modifier les classes existantes.
+::: tip
+À retenir : Le double dispatch permet de gérer des interactions complexes entre types, en déléguant la logique de décision à des classes spécifiques. Cela rend le code plus flexible et extensible, car on peut ajouter de nouveaux types d'interactions sans modifier les classes existantes.
+:::
 
 
 
-> **À retenir :**
-> Ces patterns avancés permettent de structurer des systèmes complexes et évolutifs.
+::: tip
+À retenir : Ces patterns avancés permettent de structurer des systèmes complexes et évolutifs.
+:::

docs/cours/java/10-exceptions.md

@@ -2,7 +2,9 @@
 
 La gestion des erreurs est un aspect fondamental de la programmation. En Java, ce sont les exceptions qui permettent de signaler et de traiter les situations anormales, sans faire planter tout le programme.
 
-> **À retenir** : Une exception est un événement qui interrompt le déroulement normal du programme. Elle permet de réagir proprement à une erreur, au lieu de laisser le programme s’arrêter brutalement.
+::: info À retenir
+Une exception est un événement qui interrompt le déroulement normal du programme. Elle permet de réagir proprement à une erreur, au lieu de laisser le programme s’arrêter brutalement.
+:::
 
 ## Qu'est-ce qu'une exception ?
 
@@ -14,7 +16,9 @@ Pour éviter cela, il faut gérer les exceptions à l’aide d’un bloc `try-ca
 
 Le bloc `try` permet d’« essayer » un morceau de code susceptible de générer une exception. Si une exception survient, le contrôle passe dans le bloc `catch` correspondant, où vous pouvez réagir à l’erreur.
 
-> **Info** : Vous pouvez chaîner plusieurs blocs `catch` pour gérer différents types d’exceptions, ou utiliser un seul bloc avec le type `Exception` pour tout attraper.
+::: info
+Vous pouvez chaîner plusieurs blocs `catch` pour gérer différents types d’exceptions, ou utiliser un seul bloc avec le type `Exception` pour tout attraper.
+:::
 
 Exemple :
 
@@ -32,7 +36,9 @@ catch(InputMismatchException ex){
 scanner.close();
 ```
 
-> **Attention** : Le nom de la méthode est `nextInt()` (avec un n minuscule), pas `NextInt()`.
+::: warning Attention
+Le nom de la méthode est `nextInt()` (avec un n minuscule), pas `NextInt()`.
+:::
 
 ## Finally
 
@@ -138,7 +144,9 @@ Throwable
         └── ...
 ```
 
-> **À savoir** : Les erreurs (`Error`) sont des problèmes graves (ex : mémoire insuffisante) que l’on ne cherche généralement pas à gérer.
+::: info À savoir
+Les erreurs (`Error`) sont des problèmes graves (ex : mémoire insuffisante) que l’on ne cherche généralement pas à gérer.
+:::
 
 ### Exemple pratique complet
 
@@ -185,19 +193,25 @@ public class ExceptionComparison {
 
 ### Quand utiliser quoi ?
 
-> **Utilisez les exceptions vérifiées** quand :
-> - L’erreur est prévisible et externe à votre contrôle (fichier manquant, problème réseau, etc.)
-> - L’application peut potentiellement récupérer de l’erreur
-> - Vous voulez forcer les utilisateurs de votre méthode à gérer l’exception
+::: tip
+**Utilisez les exceptions vérifiées** quand :
+- L’erreur est prévisible et externe à votre contrôle (fichier manquant, problème réseau, etc.)
+- L’application peut potentiellement récupérer de l’erreur
+- Vous voulez forcer les utilisateurs de votre méthode à gérer l’exception
+:::
 
-> **Les RuntimeException sont appropriées** quand :
-> - L’erreur représente un bug de programmation (paramètre null inattendu, index invalide, etc.)
-> - L’erreur indique un état incohérent qui ne devrait jamais arriver si le code est correct
-> - L’erreur est généralement fatale et difficile à récupérer
+::: info
+**Les RuntimeException sont appropriées** quand :
+- L’erreur représente un bug de programmation (paramètre null inattendu, index invalide, etc.)
+- L’erreur indique un état incohérent qui ne devrait jamais arriver si le code est correct
+- L’erreur est généralement fatale et difficile à récupérer
+:::
 
 Cette distinction aide à créer du code plus robuste et expressif : les exceptions vérifiées documentent les cas d’erreur que les appelants doivent considérer, tandis que les RuntimeException signalent des bugs qui doivent être corrigés plutôt que gérés.
 
-> **Pour aller plus loin** : Essayez de provoquer différentes exceptions dans vos programmes, puis entraînez-vous à les gérer proprement avec des blocs try-catch adaptés !
+::: tip
+Pour aller plus loin : Essayez de provoquer différentes exceptions dans vos programmes, puis entraînez-vous à les gérer proprement avec des blocs try-catch adaptés !
+:::
 
 
 
@@ -230,7 +244,9 @@ public class PropagationExceptionDemo {
 }
 ```
 
-> **À retenir** : Une exception peut être capturée à n’importe quel niveau de la pile d’appels. On peut choisir de la traiter, de la relancer, ou de la transformer en une autre exception plus explicite.
+::: info À retenir
+Une exception peut être capturée à n’importe quel niveau de la pile d’appels. On peut choisir de la traiter, de la relancer, ou de la transformer en une autre exception plus explicite.
+:::
 
 ## Créer ses propres exceptions
 
@@ -252,7 +268,9 @@ public class InvalidUserInputException extends Exception {
 }
 ```
 
-> **Info** : L’argument `cause` permet de conserver la trace de l’exception d’origine. Cela facilite le débogage, car on peut remonter toute la chaîne d’exceptions jusqu’à la source du problème.
+::: info
+L’argument `cause` permet de conserver la trace de l’exception d’origine. Cela facilite le débogage, car on peut remonter toute la chaîne d’exceptions jusqu’à la source du problème.
+:::
 
 Vous pouvez ensuite utiliser votre exception personnalisée dans votre code :
 
@@ -270,7 +288,9 @@ public void processUserInput(String input) throws InvalidUserInputException {
 
 Dans cet exemple, si l’utilisateur saisit une valeur non entière, une `NumberFormatException` sera levée. On la capture et on relance une exception métier plus explicite (`InvalidUserInputException`), tout en conservant la cause d’origine grâce à l’argument `cause`.
 
-> **À retenir** : Créer ses propres exceptions permet de rendre le code plus lisible, de mieux documenter les erreurs possibles, et de faciliter le suivi des causes lors du débogage.
+::: info À retenir
+Créer ses propres exceptions permet de rendre le code plus lisible, de mieux documenter les erreurs possibles, et de faciliter le suivi des causes lors du débogage.
+:::
 
 ### Affichage de la trace complète avec `printStackTrace()`
 
@@ -309,7 +329,9 @@ Caused by: java.lang.NumberFormatException: For input string: "abc"
     ...
 ```
 
-> **À retenir** : Grâce à l’argument `cause` et à `printStackTrace()`, on peut remonter toute la chaîne des erreurs, ce qui facilite grandement le débogage.
+::: info À retenir
+Grâce à l’argument `cause` et à `printStackTrace()`, on peut remonter toute la chaîne des erreurs, ce qui facilite grandement le débogage.
+:::
 
 
 ## Exemple réel : gestion et propagation d’exceptions dans une application
@@ -376,5 +398,7 @@ public class ApplicationDemo {
 - Une erreur d’analyse (`IllegalArgumentException`) est capturée, puis transformée en `AnalysisException` (exception métier).
 - Une erreur d’accès au fichier (`IOException`) est capturée et transformée en `AnalysisException`.
 
-> **À retenir** : Dans une application réelle, il est courant de laisser certaines exceptions traverser plusieurs couches, d’en relancer d’autres, ou de les transformer pour donner plus de sens au contexte métier.
+::: info À retenir
+Dans une application réelle, il est courant de laisser certaines exceptions traverser plusieurs couches, d’en relancer d’autres, ou de les transformer pour donner plus de sens au contexte métier.
+:::