FAQ MATLABConsultez toutes les FAQ

Nombre d'auteurs : 10, nombre de questions : 166, dernière mise à jour : 30 mars 2017 

 
OuvrirSommaireProgrammation orientée objet (POO)

Une classe peut être définie en utilisant le mot-clé classdefDocumentation mot clé classdef :

 
Sélectionnez
classdef maClasse
end

Pour instancier une classe, on fait ceci :

 
Sélectionnez
obj = maClasse();

Définir ainsi une classe n'a pas d'utilité. On peut lui ajouter des propriétés ou des méthodes :

 
Sélectionnez
classdef maClasse
    properties
        maProprietePublique
    end

    methods
        function x = maFonction(obj, p)
            x = 2 .* p;
        end
    end
end

Les propriétés et méthodes ainsi définies seront accessibles publiquement. Dit autrement, on peut faire ceci :

 
Sélectionnez
obj.maProprietePublique = 2;

Le premier paramètre de la méthode de la fonction sert comme référence à l'objet appelé. Dans d'autres langages, il est appelé this ou self, par exemple. Il est inutile de le préciser explicitement lors de l'appel à la fonction, MATLAB le fait implicitement grâce à la syntaxe objet.méthode(paramètre), que l'on peut comprendre comme méthode(objet, paramètre).

Créé le 5 mars 2011  par Thibaut Cuvelier

Lien : Video - Developing MATLAB Classes Overview

Pour définir une classe héritant d'une autre, on renseigne sa super classe à l'aide du caractère "<" comme suit :

 
Sélectionnez
classdef maClasse < maSuperClasse
    % ...
end
% ou si la super classe est dans un package :
classdef maClasse < monPackage.maSuperClasse
    % ...
end

Pour définir un héritage multiple, on insère le caractère "&" entre chaque super classe :

 
Sélectionnez
classdef maClasse < maSuperClasse1 & maSuperClasse2
    % ...
end

On fera attention dans ce deuxième cas à ne pas avoir de conflit entre les noms des propriétés, méthodes et évènements des super classes (voir Class Member Compatibility pour plus de détails).

Créé le 26 juin 2013  par Jérôme Marsaguet

Lien : Creating Subclasses - Syntax and Techniques

Comme dans bien d'autres langages orientés objet, le constructeur d'une classe est une méthode portant le nom de la classe. Particularité de MATLAB, cette méthode doit renvoyer un (et un seul) objet : l'instance de la classe (nommée obj ici).

 
Sélectionnez
classdef maClasse
    properties
        propriete1
        propriete2 = 42;
    end
    methods
        function obj = maClasse(<entrées>) 
            obj.propriete1 = ...; % initialisation de propriete1
            % obj.propriete2 = 42 par défaut
        end
    end
end

Cette méthode sera appelée lors de la création de l'objet et peut prendre autant de paramètres que nécessaire. Autre particularité de cette méthode, elle ne prend pas de paramètre récursif, au contraire de toutes les autres méthodes d'une classe.

 
Sélectionnez
>> instance = maClasse(3)

instance = 

  maClasse

  Properties:
    propriete1: 3
    propriete2: 42

  Methods
Mis à jour le 13 août 2014  par Thibaut Cuvelier, Jérôme Marsaguet

Lien : Appel du constructeur d'une super classe.
Lien : Class Constructor Methods

  • Appel du constructeur
    Si vous n'appelez pas explicitement le constructeur de la, ou des super classe(s), leur constructeur par défaut sera appelé (autrement dit sans aucun argument).
    Si au contraire vous souhaitez l'appeler, voici la syntaxe à utiliser :

     
    Sélectionnez
    classdef maClasse < maSuperClasse % ou monPackage.maSuperClasse dans un package
        methods
            function obj = maClasse(<arguments>)
                obj = obj@maSuperClasse(<arguments>)
                % maSuperClasse dans un package : 
                obj = obj@monPackage.maSuperClasse(<arguments>)
            end
        end
    end
  • Appel d'une méthode non surchargée
    On utilise la syntaxe usuelle :

     
    Sélectionnez
    obj.nomMethode(<arguments>)
  • Appel d'une méthode surchargée
    Supposons que l'on ait défini une méthode maFonction() dans la super classe, alors son appel dans la classe dérivée se fera comme suit :

    Cet appel est limité à la seule méthode du même nom effectuant la surcharge : ici maFonction(). Les autres méthodes ne pourront qu'appeler la méthode surchargée avec la syntaxe usuelle :
     
    Sélectionnez
    obj.maFonction(<arguments>)
     
    Sélectionnez
    classdef maClasse < maSuperClasse % ou monPackage.maSuperClasse dans un package
        methods
            function maFonction(obj, <arguments>)
                maFonction@maSuperClasse(obj, <arguments>)
                % maSuperClasse dans un package : 
                maFonction@monPackage.maSuperClasse(obj, <arguments>)
            end
        end
    end
Créé le 26 juin 2013  par Jérôme Marsaguet

Lien : Calling Superclass Methods on Subclass Objects

Par défaut, toute classe fille hérite des méthodes et des propriétés de la classe mère et peut redéfinir toutes les méthodes ainsi héritées. Il y a moyen d'éviter cela : il suffit de définir l'attribut Sealed dans la classe mère.

 
Sélectionnez
classdef Mother
    methods (Sealed)
        function x = y()
            %
        end
    end
end

classdef Child < Mother
    methods
        function x = y()
            % générera une erreur
        end
    end
end
Créé le 5 mars 2011  par Thibaut Cuvelier

Lien : Method Attributes
Lien : Specifying Attributes

Une classe abstraite ne peut pas être instanciée, c'est sa caractéristique principale. On doit en dériver en créant une autre classe, en définissant les méthodes abstraites.

On peut utiliser de telles classes pour s'assurer de l'existence de certaines méthodes à l'appel ou bien pour automatiser certaines tâches qui requièrent cependant une certaine spécialisation (on peut avoir une classe qui dessine un graphe, on veut automatiser cette opération : il suffit alors de dériver de cette classe abstraite, de redéfinir la méthode d'évaluation de la fonction et on peut réutiliser ce qui a déjà été codé).

Une classe abstraite peut donc contenir des méthodes abstraites et non abstraites (définies dans la classe). Les méthodes abstraites sont mises dans un bloc methods séparé, avec le paramètre Abstract à true :

 
Sélectionnez
classdef maClasse
    methods (Abstract)
        fonctionAbstraite(obj)
    end

    methods
        function fonctionConcrete(obj)
        
        end
    end
end

Remarquez que les méthodes abstraites n'ont pas de mot-clé function.

On peut implémenter cette fonction abstraite comme suit :

 
Sélectionnez
classdef monEnfant < maClasse
    methods
        function fonctionAbstraite(obj)
            % traitement
        end
    end
end
Mis à jour le 28 octobre 2012  par Thibaut Cuvelier

Lien : Method Attributes
Lien : Specifying Attributes

Une méthode statique est une méthode qui n'a pas besoin d'accéder aux propriétés d'un objet, son retour ne dépend pas de l'instance de la classe dans laquelle elle a été définie.

On en définit avec le paramètre Static :

 
Sélectionnez
classdef maClasse
    methods (Static)
        function x = static(y)
            x = 2 * y;
        end
    end
end

Pour appeler cette méthode, on peut utiliser directement le nom de la classe, le point suivi de la méthode statique :

 
Sélectionnez
maClasse.static(3)

On peut cependant les appeler dans toute instance de la classe :

 
Sélectionnez
obj = maClasse();
obj.static(3)
Créé le 5 mars 2011  par Thibaut Cuvelier

Lien : Static Methods
Lien : Method Attributes

Les events et listeners sont à la base du fonctionnement des fonctions callback dans les interfaces graphiques. Les events sont des notifications que les objets émettent en réponse à un changement de valeur d'une propriété, une interaction de l'utilisateur, la destruction d'un objet… Les listeners quant à eux, à l'écoute de ces notifications, permettent l'exécution de fonctions lorsqu'ils les reçoivent.
Les events sont définis dans la classe comme ceci :

Cette classe devra obligatoirement hériter de la classe handleDocumentation classe handle.

 
Sélectionnez
classdef maClasse < handle
    properties
        % ...
    end
    events
        nomEvent
    end
    methods
        % ...
    end
end

Puis au sein des méthodes de la classe, lorsque l'on voudra effectuer la notification de l'évènement, on utilisera la fonction notifyDocumentation de la fonction notify comme ceci (obj étant l'instance de la classe) :

 
Sélectionnez
notify(obj, 'nomEvent');

Si vous souhaitez faire passer des données en même temps, il vous faudra créer une classe qui hérite de la classe event.EventDataDocumentation classe event.EventData :

 
Sélectionnez
classdef monEventData < event.EventData
   properties
      
   end

   methods
      function obj = monEventData(<arguments à faire passer>)
         % ...
      end
   end
end

et l'utiliser ainsi :

 
Sélectionnez
notify(obj, 'nomEvent', monEventData(<arguments>) );



Pour ce qui est des listeners, il existe deux façons de les créer :

  • en utilisant la fonction addlistenerDocumentation de la fonction addlistener : le listener est alors lié à l'objet émettant la notification, il ne sera détruit qu'en même temps que celui-ci ;

     
    Sélectionnez
    lh = addlistener(objetEmetteur, 'nomEvent', @maFonctionCallback);
  • en utilisant le constructeur event.listenerDocumentation classe event.listener, sa durée de vie sera alors liée à celle de l'objet listener ainsi créé.

     
    Sélectionnez
    lh = event.listener(objetEmetteur, 'nomEvent', @maFonctionCallback);

La fonction callback doit comporter deux arguments :

 
Sélectionnez
function maFonctionCallback(eventSrc, eventData)
   % ...
end
  • eventSrc désignera l'objet à l'origine de l'évènement ;
  • eventData de type event.EventData (ou de votre classe qui en hérite), contiendra par défaut les champs :
    • Source : l'objet à l'origine de l'évènement ;
    • EventName : le nom de l'event à l'origine de la notification.
Créé le 26 juin 2013  par Jérôme Marsaguet

Lien : Events and Listeners - Syntax and Techniques
Lien : Events and Listeners - Concepts
Lien : Learning to Use Events and Listeners

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2007-2013 Developpez LLC Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.