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

classdef maClasse
end

Pour instancier une classe, on fait ceci :

obj = maClasse();

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

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 :

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).

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

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 :

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).

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).

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.

>> instance = maClasse(3)

instance = 

  maClasse

  Properties:
    propriete1: 3
    propriete2: 42

  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

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.

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

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 :

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 :

classdef monEnfant < maClasse
    methods
        function fonctionAbstraite(obj)
            % traitement
        end
    end
end

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 :

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 :

maClasse.static(3)

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

obj = maClasse();
obj.static(3)

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.

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) :

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 :

classdef monEventData < event.EventData
   properties
      
   end

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

et l'utiliser ainsi :

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 :

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.