Développement logiciel
Conception orientée objet et patrons de conception en Java
Formation de conception appliquée pour les développeurs Java dont le code fonctionne mais résiste au changement. Les participants examinent la cohésion, le couplage et les principes SOLID, puis abordent les patrons créationnels, structurels et comportementaux comme des compromis, y compris lorsqu'un patron coûte plus qu'il ne rapporte.
Aperçu
Un apprentissage pratique pour le transfert en situation de travail.
La connaissance des patrons s'acquiert le plus souvent comme un catalogue, avec un résultat prévisible : des fabriques qui enveloppent un unique constructeur, des hiérarchies de stratégies à une seule implémentation, une couche d'abstraction écrite pour une seconde base qui n'arrivera jamais. Chacune de ces décisions est défendue au nom de la bonne conception alors qu'elle augmente le coût du prochain changement. Cette formation traite le patron comme une décision assortie d'un prix. Les participants refactorisent du code Java réel, nomment les forces qui justifient chaque structure et retirent les patrons devenus inutiles, en s'appuyant sur les records et le pattern matching.
Prérequis
Maîtrise pratique de la syntaxe Java, des classes, des interfaces et des collections. Une expérience de maintenance d'application Java est un atout.
Objectifs
- Évaluer une conception par sa cohésion, son couplage et les changements qu'elle rend peu ou très coûteux.
- Appliquer les principes SOLID au code Java sans multiplier inutilement les classes.
- Choisir entre héritage, composition et délégation sur la base de compromis explicites.
- Mettre en oeuvre les patrons créationnels et structurels uniquement là où la construction ou les frontières varient réellement.
- Remplacer des patrons classiques par les records, les types scellés et le pattern matching de switch lorsque le langage suffit désormais.
- Refactoriser un module Java existant vers une conception capable d'absorber la prochaine exigence.
Public cible
- Développeurs Java ayant au moins un an d'expérience en production
- Responsables techniques en charge de la structure du code et des standards de revue
- Ingénieurs backend maintenant des applications métier de longue durée
- Architectes logiciels validant les conceptions avant le début de l'implémentation
- Développeurs préparant le découpage d'une application monolithique en modules
- Ingénieurs ayant hérité de bases de code qu'ils n'ont pas conçues
Programme
Une structure claire pour le parcours d'apprentissage.
Programme
Les points du programme sont regroupés dans un seul bloc au lieu de créer un module par ligne.
Module 1 : Forces de conception : cohésion, couplage et changement
Ce qu'une conception optimise : les changements que l'équipe prévoit ensuite
Mesurer cohésion et couplage sur de vraies classes et paquets Java
L'abstraction qui se rentabilise face à la généralité spéculative
Lire une base de code inconnue pour retrouver les décisions de conception non documentées
Module 2 : SOLID en pratique, pas en théorie
La responsabilité unique appliquée au niveau du module plutôt que de la méthode
L'ouverture-fermeture par des points d'extension réellement utilisés
La substitution de Liskov et les contrats implicitement promis par une hiérarchie d'héritage
Ségrégation d'interfaces et inversion de dépendances dans du code de service Java
Module 3 : Construction d'objets et patrons créationnels
Fabrique et fabrique abstraite là où l'instanciation varie réellement
Builder pour constructeurs larges, champs optionnels et objets validés
Le singleton, son coût en test et pourquoi l'injection de dépendances le remplace
Prototype et pools d'objets, et les cas fréquents où aucun n'est justifié
Module 4 : Patrons structurels et frontières du système
Adaptateur et façade pour dompter interfaces tierces et héritées
Décorateur ou héritage pour superposer des comportements à l'exécution
Composite pour les structures récursives et le coût de parcours induit
Proxy pour chargement paresseux, contrôle d'accès et appels distants
Module 5 : Patrons comportementaux et variation à l'exécution
La stratégie, et quand une enum ou une lambda constitue une meilleure réponse
Patron de méthode ou composition pour partager le squelette d'un algorithme
Observateur, publication d'événements et coût de débogage de l'indirection
État, commande et visiteur mis en balance avec leur charge de maintenance
Module 6 : Java moderne et simplification de la conception
Records et interfaces scellées en remplacement des objets valeur et des hiérarchies de types
Le pattern matching de switch comme alternative au visiteur et au double dispatch
Retirer un patron en toute sécurité en localisant d'abord tous les appelants restants
Revue de conception finale sur un module apporté par les participants eux-mêmes
Supports fournis
- Manuel de formation, exemples de code commentés et notes de référence
- Environnement de laboratoire et dépôts de démarrage
- Exercices, check-lists et modèles de code réutilisables
- Certificat de participation 4D
- Accompagnement technique après la formation
Options de formation
Les programmes peuvent être organisés en entreprise, en ligne ou dans un format hybride selon le calendrier, la localisation et les objectifs de vos équipes. Lorsqu'un certificat ou un examen externe est inclus, les règles et frais de certification restent soumis aux politiques de l'organisme certificateur, tandis que 4D assure la formation et l'accompagnement à la préparation.
Pourquoi choisir 4D
4D anime cette formation sur du code Java écrit par vos équipes, et non sur des exemples de formes et d'animaux. Chaque journée se termine par une revue de conception où formateurs et participants débattent des compromis d'un module réel, décident des abstractions à conserver et repèrent celles à retirer avant qu'elles ne se figent en une architecture intouchable.
Formations liées
Fondamentaux de la programmation Python
Une introduction pratique à Python pour les ingénieurs et analystes qui ont besoin de code opérationnel plutôt que d'extraits de tutoriel. Les participants acquièrent de l'aisance avec les types, les collections, les fonctions, les fichiers et la gestion des erreurs, puis construisent un programme complet.
View coursePython intermédiaire et pratiques de code propre
Conçue pour les développeurs dont le code Python fonctionne mais résiste au changement. Le programme couvre dataclasses, générateurs, décorateurs, gestionnaires de contexte et annotations de types, puis applique les refactorings qui transforment un module interminable en unités testées contrôlées par black, ruff et mypy.
View courseAutomatisation et scripting Python pour les tâches métier
Destinée aux équipes qui perdent chaque semaine des heures en manipulations de fichiers, de tableurs et de rapports. Les participants automatisent ces tâches avec Python : traitement de fichiers en lot, Excel et CSV, appels d'API REST, alertes par e-mail et tâches planifiées qui signalent clairement toute défaillance.
View course