Création de classes et d’objets

Objectifs de formation

Une fois cette unité terminée, vous pourrez :

Décrire la relation entre une classe et un objet
Définir un paramètre
Expliquer les différences entre les valeurs renvoyées

S’il s’agit de vos premiers pas dans le parcours Développement des compétences relatives au code Apex, vous êtes allé trop loin. Rebroussez donc chemin et terminez d’abord le module Bases d’Apex pour les administrateurs. Par contre, si vous avez déjà obtenu le badge Bases d’Apex pour les administrateurs, alors vous êtes au bon endroit.

Dans le module Bases d’Apex pour les administrateurs, vous avez découvert la syntaxe, les variables, les collections et les instructions conditionnelles Apex. Vous avez également exécuté quelques codes d’exemple dans la Developer Console. Dans ce module, nous approfondirons ces concepts. Commençons.

Signification de l’expression « orienté objet »

Si vous avez déjà lu de la documentation sur le développement ou la programmation de logiciels, alors l’expression orienté objet vous est peut-être familière : on parle de classes orientées objet, de concepts orientés objet ou encore de programmation orientée objet. Qu’est-ce que cela signifie ?

Dans le domaine des langages de programmation, l’expression « orienté objet » signifie que le code se concentre sur la description d’objets. Tout ce qui présente des caractéristiques uniques peut être un objet : une personne, un compte ou même une fleur. Avant de pouvoir vraiment comprendre ce que signifie « orienté objet », vous devez comprendre deux concepts : les classes et les objets.

Vidéo de démonstration Trail Together

Vous souhaitez être guidé pas à pas par un expert pendant que vous travaillez sur cette étape ? Regardez cette vidéo qui fait partie de la série Trail Together sur Trailhead Live. Vous trouverez un lien vers la session complète dans la section Ressources.

Classes

Une classe est une sorte de plan directeur. Les objets sont basés sur cette dernière. Une classe désigne un ensemble de caractéristiques et de comportements communs à tous les objets lui appartenant.

Prenons comme exemple une fleur. Elle présente des caractéristiques telles que sa couleur et sa taille, ainsi que des comportements tels que sa pousse et son flétrissement. Dans une classe Apex, les caractéristiques sont appelées variables et les comportements sont appelés méthodes.

Une fleur.

Caractéristiques (variables)	Comportements (méthodes)
color	Grow
height	Pollinate
maxHeight	Wilt
numberOfPetals

Imaginez un jardin. Bien que les roses, les lys et les marguerites soient de couleur et de taille différentes, ce sont toutes des fleurs et elles ont toutes une couleur et une taille.

Une fleur de couleur pâle représentant la classe, au-dessous de laquelle se trouvent trois fleurs plus petites représentant les instances de la classe.

Déclaration d’une classe

Ce code déclare (crée) une classe :

public class Flower { //corps de la classe }

Les classes sont déclarées en utilisant quatre parties : le modificateur d’accès, le mot-clé "class", puis le nom et le corps de la classe. Ce dernier (situé à l’intérieur des accolades {} ) constitue l’emplacement où sont définies les méthodes et les variables de la classe.

Modificateurs d’accès

Un modificateur d’accès est un mot-clé présent dans une déclaration de classe ou de méthode. Le modificateur d’accès détermine quel autre code Apex peut consulter et utiliser la classe ou la méthode. Bien qu’il existe d’autres modificateurs d’accès, le modificateur public est le plus courant. Les classes publiques sont disponibles pour toutes les autres classes Apex de votre organisation.

Méthodes

Les méthodes sont définies dans une classe. Elles décrivent les comportements hérités par les objets de cette classe. Une classe peut contenir une ou plusieurs méthodes. La classe Flower dispose de trois méthodes (comportements) : grow, pollinate et wilt.

Une méthode est déclarée (créée) comme ceci :

public static Integer wilt(Integer numberOfPetals){ //corps de la méthode }

Paramètres

Lors de la création de méthodes, l’ensemble des valeurs nécessaires à l’exécution du code n’est pas toujours connu. Souvent, il arrive de devoir écrire une méthode effectuant une tâche, puis une deuxième méthode effectuant une tâche similaire, etc. Avec le recul, on finit par constater que toutes ces méthodes ont presque la même finalité. Il s’agit de doublons présentant seulement de légères variations.

Si seulement il nous était possible d’utiliser plusieurs entrées avec la même méthode… Attendez ! Nous pouvons utiliser des paramètres ! Un paramètre est une variable agissant comme un espace réservé attendant de recevoir une valeur. Les paramètres sont déclarés de manière semblable à une variable : elles présentent un type de données suivi du nom du paramètre. Dans la déclaration suivante, la méthode wilt a un paramètre nommé numberOfPetals (Bien que vous puissiez nommer les paramètres comme bon vous semble, il est recommandé d’utiliser des noms décrivant la valeur que le paramètre contient.) Le paramètre numberOfPetals s’attend à recevoir une valeur dont le type de données est integer.

public static void wilt (Integer numberOfPetals){ //corps de la méthode}

Comment appeler (utiliser) la méthode wilt ? Dans cet exemple de code, la première ligne appelle (utilise) la méthode et transmet (envoie) la valeur 4. La valeur que vous transmettez s’appelle un argument. L’argument (ici, 4) est placé entre des parenthèses après le nom de la méthode.

wilt(4);
public static void wilt(Integer numberOfPetals){
    system.debug(numberOfPetals);
}

Lorsqu’une valeur est transmise à une méthode comportant un paramètre, la valeur de l’argument devient alors la valeur du paramètre. Le paramètre fonctionnant comme une variable, vous pouvez le manipuler comme n’importe quelle autre variable.

Examinons la classe Flower.

public class Flower {
    public static void wilt(Integer numberOfPetals){
        if(numberOfPetals >= 1){
            numberOfPetals--;
        }
    }
}

Aux lignes 2 à 6 de la classe Flower, la méthode wilt vérifie la valeur de numberOfPetals. Si ce nombre est supérieur ou égal à 1, la méthode wilt décrémente (réduit) de un la valeur de numberOfPetals.

Types de renvoi

Imaginez que vous êtes dans un restaurant et que vous souhaitez savoir si l’établissement propose un plat de saison. Vous demandez au serveur : « Avez-vous une salade d’été ? » Ici, vous attendez un type de réponse particulier : pas un nombre ou une phrase complète, mais un « oui » ou un « non ».

Une déclaration de méthode doit énoncer explicitement le type de renvoi qu’elle attend. Tout comme un argument doit correspondre au type de données indiqué par le paramètre, une variable renvoyée doit correspondre au type de renvoi indiqué par la déclaration de méthode. Le type de renvoi est un type de données spécifique, tel que Boolean (booléen), String (chaîne) ou Account (compte), ou peut également être void (rien), comme dans l’exemple suivant :

public static void wilt(Integer numberOfPetals){
    system.debug(numberOfPetals);
}

Lorsque le type de renvoi de la méthode est void, la méthode ne renvoie aucune valeur. Pour renvoyer une valeur, il vous faut remplacer void par un type de renvoi différent.

Par exemple, ici, la méthode wilt attend une valeur return (de renvoi) qui est un entier.

public static Integer wilt (Integer numberOfPetals){ //corps de la méthode}

public static Integer wilt(Integer numberOfPetals){
    if(numberOfPetals >= 1){
        numberOfPetals--;
    }
  
    return numberOfPetals;
}

Dans la ligne 1, le type de renvoi Integer (situé immédiatement après public static) indique que la méthode renvoie une valeur qui est un entier. La ligne 6 emploie l’instruction return suivie du nom de la variable numberOfPetals, pour renvoyer la valeur résultante de numberOfPetals. Lorsqu’une méthode renvoie une valeur de variable, le type de données de la variable doit correspondre au type de renvoi déclaré par la méthode. Ici, la méthode wilt doit renvoyer une valeur entière (de type integer) et la variable numberOfPetals est de ce type.

Mettons donc à l’essai les méthodes wilt, grow et pollinate. Finissons tout d’abord de les coder.

Écriture des méthodes

Dans la Developer Console, cliquez sur File (Fichier) | New (Nouveau) | Apex Class (Classe Apex).
Saisissez le nom de classe Flower.
Cliquez sur OK.

Dans la classe Flower.apxc, remplacez le code existant par le code suivant :

public class Flower {
    // class variables:
    public String color;
    public Integer height;
    public Integer maxHeight;
    public Integer numberOfPetals;
  
    public static Integer wilt(Integer numberOfPetals){
        if(numberOfPetals >= 1){
            numberOfPetals--;
        }
        return numberOfPetals;
    }
  
    public static void grow(Integer height, Integer maxHeight){
        height = height + 2;
        if(height >= maxHeight){
            pollinate();
        }
    }
  
    public static void pollinate(){
        System.debug('Pollinating...');
    }
}

Cliquez sur File (Fichier) | Save (Enregistrer).

Maintenant que vous disposez d’une classe complètement définie, vous êtes prêt à la tester. Vous n’avez besoin que du nom de la classe (Flower), des méthodes que vous voulez tester (wilt et grow) et des arguments nécessaires à ces dernières. Étant donné que la méthode grow appelle (utilise) la méthode pollinate, vous n’avez pas besoin d’appeler directement la méthode pollinate. La méthode wilt attend une valeur entière (pour le paramètre numberOfPetals) et renvoie une valeur entière. Les méthodes grow et pollinate, elles, ne renvoient rien.

Exécution des méthodes

Cliquez sur Debug (Débogage) | Open Execute Anonymous Window (Ouvrir une fenêtre d’exécution anonyme).
Dans la fenêtre Enter Apex Code (Entrer du code Apex), collez le code suivant :
```
Flower.wilt(4);
Flower.grow(5, 7);
```
Sélectionnez Open log (Ouvrir le journal), puis cliquez sur Execute (Exécuter). Le journal d’exécution s’ouvre et affiche le résultat de l’exécution de votre code.
Sélectionnez Debug Only (Déboguer uniquement).

La méthode grow comporte deux paramètres, height et maxHeight.

Flower.grow(5, 7); transfère les arguments 5 (la taille est de 5 cm) et 7 (la taille maximale est de 7 cm) à la méthode grow. La méthode grow ajoute 2 à la variable height (ligne 9), puis vérifie la valeur de cette même variable, height. Si la valeur de la variable height est supérieure ou égale à la valeur de la variable maxHeight, la méthode grow appelle la méthode pollinate.

La méthode pollinate ne renvoie rien, son type de renvoi étant void.

Que s'est-il passé ?

Vous devriez voir l’entrée suivante dans le journal de débogage :

Événement : USER_DEBUG. Détails : [18]|DEBUG|Pollinisation…

Selon vous, que va-t-il se passer si vous utilisez 2 et 6 comme paramètres de la méthode grow ? Essayez-donc pour voir.

Alors, que se passe-t-il ?

En consultant les journaux de débogage, vous constatez qu’il ne se passe visiblement rien. En effet, en définissant height sur 2 et maxHeight sur 6, la condition de l’instruction if devient fausse, ce qui empêche la méthode pollinate d’être exécutée.

Objets

Rappelez-vous que la classe Flower représente un plan directeur pour la création de fleurs. Elle contient les variables color, height, maxHeight et numberOfPetals Ces variables sont égales à null (sans valeur), mais peuvent avoir des valeurs par défaut.

Un objet est une instance d’une classe. Tout comme les enfants héritent de traits génétiques de leurs parents, tels que la couleur des yeux et la taille, les objets héritent de variables et de méthodes de leurs classes.

color = null; height = null; maxHeight = null; numberOfPetals = null;	Classe Flower	grow() pollinate() wilt()

color = 'jaune';	color ='rouge';	color = 'rose';
height = 3;	height = 6;	height = 9;
maxHeight = 6;	maxHeight = 8;	maxHeight = 9;
numberOfPetals = 4;	numberOfPetals = 6;	numberOfPetals = 10;
`Flower tulip = new Flower(); tulip.color = 'yellow'; tulip.height = 3; tulip.maxHeight = 6; tulip.numberOfPetals = 4; tulip.grow();`	`Flower rose = new Flower(); rose.color = 'red'; rose.height = 6; rose.maxHeight = 8; rose.numberOfPetals = 6; rose.grow();`	`Flower peony = new Flower(); peony.color = 'pink'; peony.height = 9; peony.maxHeight = 9; peony.numberOfPetals = 10; peony.grow();`

L’objet tulip est une instance de la classe Flower. Chacun de ces trois objets Flower représente une espèce de fleur spécifique, s’appuyant sur la classe Flower. Pour créer une instance nommée tulip s’appuyant sur la classe Flower, utilisez la syntaxe suivante :

Flower tulip = new Flower();

Vous pouvez utiliser la notation pointée pour appeler les méthodes d’un objet. Ajoutez simplement .method(); après le nom de l’objet. Par exemple :

tulip.grow();

Vous savez maintenant que les objets sont des instances de classes. Dans une classe, les variables décrivent l’objet et les méthodes définissent les actions que celui-ci peut effectuer. Vous avez également manipulé des paramètres afin de recevoir les valeurs transmises dans une variable, ainsi que les types de renvoi, qui renvoient quelque chose (ou rien, selon le type de données) à une méthode.