La traduction de cette page n'est pas à jour. Cliquez ici pour voir la dernière version en anglais.

Créer une classe simple

Concevoir une classe

L’objectif principal d’une classe est de définir un objet qui contient à la fois les données et les opérations appliquées à celles-ci. Par exemple, BasicClass définit une propriété et deux méthodes qui s’appliquent aux données de cette propriété :

  • Value : propriété qui contient les données numériques stockées dans un objet de la classe

  • roundOff : méthode qui arrondit la valeur de la propriété à deux décimales

  • multiplyBy : méthode qui multiplie la valeur de la propriété par le nombre spécifié

Commencez la définition d’une classe par un bloc classdef ClassName...end. Définissez ensuite les propriétés et les méthodes de la classe dans ce bloc. Voici la définition de BasicClass :

classdef BasicClass
   properties
      Value {mustBeNumeric}
   end
   methods
      function r = roundOff(obj)
         r = round([obj.Value],2);
      end
      function r = multiplyBy(obj,n)
         r = [obj.Value]*n;
      end
   end
end

Pour un résumé de la syntaxe des classes, consultez classdef.

Pour utiliser la classe :

  • Enregistrez la définition de classe dans un fichier .m portant le même nom que la classe.

  • Créez un objet de la classe.

  • Accédez aux propriétés pour affecter les données.

  • Appelez des méthodes pour appliquer des opérations aux données.

Créer un objet

Créez un objet de la classe avec le nom de la classe :

a = BasicClass
a = 

  BasicClass with properties:

    Value: []

Au départ, la valeur de propriété est vide.

Accéder aux propriétés

Affectez une valeur à la propriété Value en utilisant la variable de l’objet et un point avant le nom de la propriété :

a.Value = pi/3;

Pour renvoyer une valeur de propriété, utilisez la notation pointée sans l’affectation :

a.Value
ans =

    1.0472

Pour plus d’informations sur les propriétés de classe, consultez Property Syntax.

Appeler des méthodes

Appelez la méthode roundOff sur l’objet a :

roundOff(a)
ans =

    1.0500

Passez l’objet en tant que premier argument à une méthode acceptant plusieurs arguments, comme dans cet appel à la méthode multiplyBy :

multiplyBy(a,3)
ans =

    3.1416

Vous pouvez également appeler une méthode avec la notation pointée :

a.multiplyBy(3)

Il n’est pas nécessaire de passer l’objet en tant qu’argument explicite lorsque vous utilisez la notation pointée. Dans cette notation, l’objet est indiqué à gauche du point.

Pour plus d’informations sur les méthodes de classe, consultez Method Syntax.

Ajouter un constructeur

Les classes peuvent définir une méthode spéciale, appelée constructeur, pour créer des objets de la classe. Les méthodes de constructeur permettent de passer des arguments au constructeur et de les affecter en tant que valeurs de propriété. La propriété BasicClass Value limite ses valeurs possibles avec la fonction mustBeNumeric.

Voici un constructeur pour la classe BasicClass. Lorsque vous appelez le constructeur avec un argument en entrée, ce dernier est affecté à la propriété Value. Si vous appelez le constructeur sans argument en entrée, la propriété Value a une valeur par défaut vide ([]).

methods        
    function obj = BasicClass(val)
        if nargin == 1
            obj.Value = val;
        end
    end
end

En ajoutant ce constructeur à la définition de classe, vous pouvez créer un objet et définir la valeur de propriété en une seule étape :

a = BasicClass(pi/3)
a = 

  BasicClass with properties:

    Value: 1.0472

Le constructeur peut effectuer d’autres opérations liées à la création d’objets de la classe.

Pour plus d’informations sur les constructeurs, consultez Class Constructor Methods.

Vectoriser les méthodes

MATLAB® permet de vectoriser les opérations. Par exemple, vous pouvez ajouter un nombre à un vecteur :

[1 2 3] + 2
ans =

     3     4     5

MATLAB ajoute le nombre 2 à chacun des éléments du tableau [1 2 3]. Pour vectoriser les méthodes d’opérateurs arithmétiques, placez la référence à la propriété obj.Value entre crochets. 

[obj.Value] + 2

Cette syntaxe permet à la méthode de fonctionner avec des tableaux d’objets. Par exemple, créez un tableau d’objets avec une affectation indexée. 

obj(1) = BasicClass(2.7984);
obj(2) = BasicClass(sin(pi/3));
obj(3) = BasicClass(7);

Les deux expressions suivantes sont équivalentes.

[obj.Value] + 2
[obj(1).Value obj(2).Value obj(3).Value] + 2

La méthode roundOff est vectorisée, car la référence à la propriété est placée entre crochets.

r = round([obj.Value],2);
Comme la méthode roundOff est vectorisée, elle peut s’appliquer à des tableaux.

roundOff(obj)
ans =

    2.8000    0.8700    7.0000

Surcharger les fonctions

Les classes peuvent implémenter des fonctionnalités existantes comme l’addition en définissant une méthode portant le même nom que la fonction MATLAB correspondante. Supposons par exemple que vous souhaitiez additionner deux objets BasicClass. Cela consiste logiquement à additionner les valeurs des propriétés Value de chaque objet.

Voici une version surchargée de la fonction MATLAB plus. Elle définit l’addition de la classe BasicClass comme l’addition des valeurs de propriété :

methods
   function r = plus(o1,o2)
      r = [o1.Value] + [o2.Value];
   end
end

En implémentant une méthode appelée plus, vous pouvez utiliser l’opérateur « + » avec les objets de BasicClass.

a = BasicClass(pi/3);
b = BasicClass(pi/4);
a + b
ans =

    1.8326

En vectorisant la méthode plus, vous pouvez l’appliquer à des tableaux d’objets.

a = BasicClass(pi/3);
b = BasicClass(pi/4);
c = BasicClass(pi/2);
ar = [a b];
ar + c
ans =

    2.6180    2.3562

Informations connexes

Pour plus d’informations sur la surcharge de fonctions, consultez Overload Functions in Class Definitions.

Pour plus d’informations sur la surcharge d’opérateurs, consultez Operator Overloading.

Listing du code BasicClass

Voici la définition de BasicClass après l’ajout des fonctionnalités décrites dans cette rubrique :

classdef BasicClass
    properties
        Value {mustBeNumeric}
    end
    methods
        function obj = BasicClass(val)
            if nargin == 1
                obj.Value = val;
            end
        end
        function r = roundOff(obj)
            r = round([obj.Value],2);
        end
        function r = multiplyBy(obj,n)
            r = [obj.Value] * n;
        end
        function r = plus(o1,o2)
            r = [o1.Value] + [o2.Value];
        end
    end
end

Voir aussi

Rubriques