Formation MATLAB - Programmation orientée objet

Concevoir des applications structurées, modulaires et maintenables

MATLAB est largement utilisé dans les domaines de l'ingénierie, du calcul scientifique et de la recherche pour développer des algorithmes, analyser des données et réaliser des simulations numériques.

Lorsque les projets deviennent plus complexes, leur organisation autour de scripts et de fonctions indépendantes peut rendre leur maintenance difficile : duplication de code, dépendances entre composants, multiplication des paramètres et difficultés à faire évoluer les traitements.

La programmation orientée objet (POO) permet de mieux structurer ces projets en associant les données et les traitements à des objets dont les responsabilités sont clairement définies.

MATLAB dispose de fonctionnalités orientées objet particulièrement adaptées au développement scientifique :

• Classes et encapsulation : organiser les données, les propriétés et les méthodes au sein de composants cohérents.
• Objets par valeur et par référence : maîtriser les comportements spécifiques des objets MATLAB.
• Héritage et polymorphisme : créer des composants extensibles et réutilisables.
• Validation et contrôle des accès : garantir la cohérence des données manipulées.
• Architecture et qualité logicielle : structurer les projets, automatiser les tests et faciliter leur maintenance.

En 5 jours, cette formation vous permettra de :

• Concevoir des classes MATLAB répondant à des besoins professionnels.
• Structurer une application autour de composants réutilisables.
• Exploiter les mécanismes d'héritage, de polymorphisme et de composition.
• Organiser et maintenir des projets MATLAB orientés objet.
• Développer et tester une application complète sans interface graphique.

La progression repose sur des travaux pratiques et un projet fil rouge de traitement de données scientifiques.

À l'issue de la formation, le participant sera capable de :

1. Comprendre les principes de la programmation orientée objet et leur mise en œuvre dans MATLAB.
2. Concevoir des classes avec leurs propriétés, méthodes et constructeurs.
3. Contrôler l'accès aux données et valider les propriétés des objets.
4. Distinguer les classes par valeur des classes par référence et choisir le comportement adapté.
5. Mettre en œuvre l'héritage, l'abstraction, le polymorphisme et la composition.
6. Organiser une application MATLAB en classes, packages et projets.
7. Appliquer des principes de conception favorisant la modularité et la maintenabilité.
8. Développer des tests unitaires pour valider le fonctionnement des classes.
9. Réaliser un projet MATLAB orienté objet structuré et réutilisable.

Professionnels utilisant MATLAB dans le cadre de projets techniques ou scientifiques :

• Ingénieurs et développeurs MATLAB souhaitant structurer leurs applications.
• Ingénieurs R&D développant des outils de calcul et d'analyse.
• Chercheurs et scientifiques devant maintenir ou faire évoluer du code MATLAB.
• Ingénieurs en calcul numérique souhaitant organiser leurs modèles et traitements.
• Professionnels chargés de la maintenance et de l'évolution de logiciels MATLAB.

Intermédiaire

• Maîtriser les fondamentaux de la programmation MATLAB.
• Savoir manipuler les matrices, vecteurs, tableaux de cellules et structures.
• Savoir développer des scripts et des fonctions avec paramètres et valeurs de retour.
• Connaître les structures conditionnelles, les boucles et la gestion des erreurs.
• Être capable d'organiser un programme en plusieurs fichiers.

Une première expérience de la programmation orientée objet dans un autre langage est utile, mais non obligatoire.

Un questionnaire de positionnement peut être proposé avant la formation.

• Concevoir des classes avec classdef.
• Développer des constructeurs et des méthodes adaptées aux besoins métiers.
• Définir des propriétés contrôlées et validées.
• Maîtriser la sémantique des objets par valeur et par référence.
• Exploiter l'héritage, les classes abstraites et le polymorphisme.
• Choisir entre composition et héritage.
• Organiser un projet en composants et packages MATLAB.
• Adapter certaines opérations natives aux objets personnalisés.
• Tester les classes avec matlab.unittest.
• Refactoriser et maintenir une application MATLAB orientée objet.

La formation est exclusivement consacrée à la programmation orientée objet et à la conception logicielle avec MATLAB.

Elle couvre les classes, les mécanismes objet, la gestion des propriétés, l'architecture des projets, les tests et les bonnes pratiques de développement.

Elle n'aborde pas Simulink, App Designer, le développement d'interfaces graphiques ni les toolboxes de modélisation spécialisées.

Les calculs scientifiques servent de supports pédagogiques aux exercices de conception objet, sans nécessiter de connaissances avancées en méthodes numériques.

5 jours (35 heures).

• Inter-entreprise : formation à distance, selon le calendrier des sessions proposées.
• Intra-entreprise : formation à distance ou dans vos locaux, pour un groupe de 8 participants maximum.

JOUR 1 - Fondements de la programmation orientée objet avec MATLAB (7 h)

1. Comprendre la programmation orientée objet (1 h 30)

• Identifier les limites d'une organisation reposant exclusivement sur des scripts et fonctions.
• Comprendre les notions de classe, objet, instance, propriété et méthode.
• Découvrir les principes d'abstraction et d'encapsulation.
• Identifier les responsabilités d'un objet.
• Comprendre l'organisation d'une classe MATLAB avec classdef.
• Instancier une classe et manipuler ses objets.
• Comparer programmation procédurale et programmation orientée objet.

Travaux pratiques : transformer une structure de données associée à plusieurs fonctions en une première classe MATLAB.

2. Définir des classes et contrôler leurs propriétés (2 h 30)

• Déclarer des propriétés et des méthodes.
• Construire et initialiser les objets avec un constructeur.
• Utiliser les propriétés publiques et privées.
• Contrôler la lecture et la modification avec GetAccess et SetAccess.
• Définir des valeurs par défaut.
• Valider les propriétés : type, dimensions, contraintes numériques.
• Utiliser les blocs arguments dans les méthodes.
• Définir des méthodes d'accès aux données et aux résultats.

Travaux pratiques : créer une classe représentant un jeu de mesures scientifiques, avec validation des données et méthodes de calcul élémentaires.

3. Concevoir et manipuler ses premiers objets (3 h)

• Identifier les invariants d'une classe.
• Organiser les méthodes selon leurs responsabilités.
• Manipuler plusieurs instances.
• Utiliser des tableaux d'objets.
• Éviter les modifications incohérentes des propriétés.
• Documenter les méthodes et les propriétés.
• Déboguer les constructeurs et les appels de méthodes.

Travaux pratiques : enrichir la classe précédente pour gérer plusieurs séries de mesures, effectuer des traitements et contrôler la cohérence des données.

JOUR 2 - Comportement, cycle de vie et gestion des objets (7 h)

4. Classes par valeur et classes par référence (2 h)

• Comprendre la sémantique des objets par valeur.
• Étudier le comportement des objets lors des affectations.
• Découvrir les classes dérivées de handle.
• Comprendre le partage de références entre variables.
• Comparer les modifications d'objets par valeur et par référence.
• Identifier les risques liés aux états partagés.
• Choisir la sémantique adaptée à un besoin.

Travaux pratiques : implémenter deux variantes d'un même composant et analyser les différences de comportement lors des copies et modifications.

5. Gérer le cycle de vie et les relations entre objets (2 h)

• Initialiser correctement les objets.
• Mettre à jour les états internes.
• Définir des méthodes de modification cohérentes.
• Comprendre le rôle de delete dans les classes par référence.
• Manipuler des références vers plusieurs objets.
• Éviter les dépendances et modifications involontaires.
• Introduire les relations entre objets.

Travaux pratiques : développer un gestionnaire de ressources scientifiques regroupant plusieurs objets et contrôlant leurs modifications.

6. Exploiter les propriétés avancées et la validation (3 h)

• Utiliser les propriétés dépendantes avec Dependent.
• Définir des méthodes d'accès et de modification adaptées.
• Découvrir les méthodes statiques.
• Différencier données stockées et données calculées.
• Contrôler les valeurs avec les mécanismes de validation MATLAB.
• Lever et traiter les exceptions avec error, try et catch.
• Construire des composants cohérents même en cas de données invalides.

Travaux pratiques : enrichir les classes développées en ajoutant des propriétés calculées, des contrôles de cohérence et une gestion explicite des erreurs.

JOUR 3 - Héritage, polymorphisme et conception objet (7 h)

7. Concevoir des hiérarchies de classes (2 h)

• Comprendre les mécanismes d'héritage.
• Définir une classe dérivée.
• Réutiliser et spécialiser les comportements d'une classe parente.
• Redéfinir des méthodes.
• Manipuler les constructeurs dans une hiérarchie.
• Comprendre les restrictions d'accès et les propriétés héritées.
• Identifier les limites de l'héritage.

Travaux pratiques : concevoir plusieurs classes spécialisées de mesures scientifiques à partir d'un comportement commun.

8. Utiliser l'abstraction et le polymorphisme (2 h)

• Comprendre les classes abstraites.
• Déclarer des méthodes abstraites.
• Définir un contrat de comportement commun.
• Exploiter le polymorphisme.
• Manipuler différentes implémentations d'une même abstraction.
• Comprendre les contraintes des collections d'objets hétérogènes dans MATLAB.
• Concevoir des traitements indépendants de la classe concrète.

Travaux pratiques : développer plusieurs stratégies de traitement des données partageant une interface commune.

9. Choisir une architecture orientée objet adaptée (3 h)

• Comprendre les relations d'association et de composition.
• Comparer composition et héritage.
• Identifier les responsabilités des composants.
• Introduire les principes SOLID adaptés à MATLAB.
• Réduire le couplage entre classes.
• Favoriser la réutilisation et l'extension des traitements.
• Représenter simplement les relations entre classes.
• Refactoriser une hiérarchie devenue trop complexe.

Travaux pratiques : restructurer une application comportant plusieurs traitements scientifiques en privilégiant la composition et le polymorphisme lorsque cela est pertinent.

JOUR 4 - Architecture, réutilisation et qualité logicielle (7 h)

10. Structurer un projet MATLAB professionnel (2 h)

• Organiser les fichiers de classes et les fonctions.
• Utiliser les espaces de noms avec les dossiers de packages +package.
• Gérer les dépendances et les chemins d'accès.
• Créer et organiser un MATLAB Project.
• Découvrir le format de configuration matlab.toml introduit dans R2026b.
• Comprendre la gestion des versions avec Git.
• Identifier les dépendances d'un projet.
• Préparer un ensemble de classes réutilisables.

Travaux pratiques : organiser les composants développés au sein d'un MATLAB Project structuré en packages.

11. Tester les classes MATLAB (2 h)

• Comprendre les principes des tests unitaires.
• Découvrir le framework matlab.unittest.
• Créer des tests à partir de matlab.unittest.TestCase.
• Vérifier les résultats des méthodes.
• Tester les constructeurs et la validation des propriétés.
• Contrôler les comportements attendus en cas d'erreur.
• Organiser et exécuter une suite de tests.
• Introduire les tests de non-régression.

Travaux pratiques : écrire une suite de tests pour vérifier le fonctionnement des classes, leurs validations et leurs interactions.

12. Personnaliser les comportements des classes (1 h 30)

• Découvrir la surcharge de méthodes et d'opérateurs.
• Adapter l'affichage et la représentation des objets.
• Définir des opérations adaptées aux types de données métiers.
• Comprendre les limites de la personnalisation des opérateurs.
• Distinguer méthodes d'instance et méthodes statiques.
• Préserver la cohérence de l'interface publique des classes.

Travaux pratiques : ajouter des opérations personnalisées à une classe de données scientifiques.

13. Améliorer la qualité et la maintenabilité (1 h 30)

• Repérer les responsabilités mal réparties.
• Identifier les duplications de code.
• Refactoriser les méthodes et les relations entre objets.
• Contrôler les dépendances entre composants.
• Utiliser les outils d'analyse de code de MATLAB.
• Documenter les interfaces publiques.
• Préparer un projet à son évolution et à sa maintenance.

Travaux pratiques : analyser et améliorer une partie du projet en conservant les tests existants.

JOUR 5 - Projet de synthèse : concevoir une bibliothèque de calcul orientée objet (7 h)

14. Conception et développement du projet (5 h)

À partir d'un cahier des charges, les participants conçoivent une bibliothèque MATLAB permettant de manipuler, traiter et analyser des ensembles de mesures scientifiques.

Le projet comporte plusieurs composants dont les responsabilités doivent être définies avant le développement.

Fonctionnalités attendues :

• Concevoir une architecture orientée objet cohérente.
• Développer des classes avec propriétés et méthodes.
• Valider les données fournies aux objets.
• Utiliser des objets par valeur ou par référence selon les besoins.
• Mettre en œuvre l'héritage et le polymorphisme.
• Réutiliser des composants à travers la composition.
• Organiser les classes en packages.
• Gérer les erreurs et les situations inattendues.
• Documenter les principales interfaces.

Travaux pratiques : réaliser progressivement la bibliothèque à partir des exigences fonctionnelles, puis vérifier son fonctionnement avec plusieurs jeux de données.

15. Tests, validation et revue de code (2 h)

• Développer une suite de tests unitaires.
• Vérifier les cas nominaux et les cas limites.
• Exécuter les contrôles de qualité.
• Corriger les anomalies identifiées.
• Refactoriser les éléments nécessitant des améliorations.
• Présenter et justifier les choix de conception.
• Évaluer l'organisation, la réutilisabilité et la maintenabilité du projet.

Livrable : une bibliothèque MATLAB orientée objet comportant plusieurs classes, une organisation en packages, des tests automatisés et une documentation technique.

La formation associe explications techniques, démonstrations, exercices de programmation et réalisation progressive d'un projet orienté objet.

Chaque mécanisme est introduit à travers un besoin de conception, puis appliqué dans un exercice pratique.

Les participants développent leurs propres classes à partir d'énoncés fonctionnels. Les corrections permettent de comparer les choix de conception, d'identifier les erreurs fréquentes et d'améliorer progressivement les solutions.

Un projet fil rouge accompagne les quatre premières journées avant la réalisation d'un projet de synthèse le cinquième jour.

• Questionnaire de positionnement initial.
• Exercices pratiques sur les concepts objet.
• Vérifications régulières des acquis.
• Évaluation des classes et de leurs interactions.
• Tests automatisés des composants développés.
• Projet final avec présentation des choix de conception.

L'évaluation porte sur la conformité fonctionnelle, le respect des principes objet, la cohérence de l'architecture, la robustesse du code et la capacité à justifier les choix d'implémentation.

• MATLAB R2026b ou version ultérieure compatible.
• Éditeur MATLAB et outils de débogage intégrés.
• Classes classdef, handle, propriétés et méthodes.
• Validation des propriétés et blocs arguments.
• Packages MATLAB et MATLAB Projects.
• Configuration des projets avec matlab.toml (R2026b).
• Tests unitaires avec matlab.unittest.
• Git pour le suivi des versions.

Les exercices sont conçus pour fonctionner avec MATLAB de base, sans toolbox supplémentaire obligatoire.

La version de MATLAB et les moyens techniques nécessaires sont précisés avant la session.

En intra-entreprise comme en inter-entreprise, deux modalités peuvent être envisagées :

• Budget direct : financement par l'entreprise ou le participant.
• Portage Qualiopi : réalisation par l'intermédiaire d'un organisme partenaire certifié, selon les conditions d'éligibilité et l'accord du partenaire.

Les modalités de financement sont étudiées en fonction du contexte de la formation.

Vous souhaitez concevoir des applications MATLAB mieux structurées et plus faciles à maintenir ?

Contactez-moi pour définir une formation adaptée aux besoins techniques de votre équipe.