Les Classes

(1)

IFT 1175 / H05 Page 1 Module 2

Les Classes

Dans la programmation contemporaine, généralement désignée sous le vocable P.O.O. ou Programmation Orientée Objet, il existe un concept largement utilisé : les classes. Une classe représente la description générale d’un ensemble d’objets, d’événements, d’actions et/ou de concepts. Par exemple, l’ensemble des êtres humains sur la Terre peut être représenté tout simplement par une classe qui contient les caractéristiques de base d’un être humain (Nom, Prénom, Date de Naissance, Poids, Lieu, Profession, etc.). Pour ce type de données, on pourrait penser utiliser un type personnalisé (structure) au lieu d’une classe. Le problème, c’est que très souvent, dans la définition d’un ensemble, nous avons aussi besoin de définir des actions ou des événements. Comme les types personnalisés, les classes nous permettent de définir des propriétés permettent de définir des variables constituantes. Mais en plus, on peut y définir des événements et des méthodes.

Un représentant concret d’une classe s’appelle : objet. Créer un objet, à partir d’une classe, s’appelle : « instancier » (On dit qu’on instancie des objets et qu’un objet est une instance de sa classe). Il existe plusieurs manières de créer des classes dans un projet. La manière la plus simple est de cliquer sur le menu Project et en choisissant l’option Ajouter une classe qui créera un module contenant la classe. Lorsqu’un fichier de type .vb représentant un module de classe est ajouté dans le projet, son nom par défaut sera Class1.vb. Pour construire un objet de type Class1 il nous faut les déclarations suivantes :

Dim UnObjet as Class1 ...

UnObjet = new Class1()

Ou bien directement :

Dim UnObjet as new Class1() ou

Dim UnObjet as Class1 = new Class1()

Dans le cadre d’une classe, les règles de visibilité sont les mêmes que celles spécifiées pour les modules et les feuilles. Toute variable, propriété, fonction ou procédure déclarée comme Private ne sera visible que dans le cadre de sa classe; et celles qui sont Public seront visibles par toutes les composantes du programme. On trouve en plus une règle intermédiaire Friend qui permet l'accès de l'intérieur du projet seulement. Chaque objet d'une classe quelconque contient ses propres propriétés, méthodes et événements avec leurs valeurs à un instant donné. Ces valeurs donnent les spécifications et les caractéristiques de l’objet en question. On dit parfois qu’un objet représente la personnification de sa classe. Chaque fois qu’un objet exécute une de ses méthodes ou de ses événements on dit que l’objet est actif.

Une classe peut contenir des instances d’autres objets en plus de ses propriétés, de ses événements et de ses méthodes.

(2)

Les propriétés

Il y a deux façons de définir une propriété. La première consiste à déclarer une variable avec Public, ce qui la rend accessible aux autres modules du projet. L’autre façon consiste à utiliser les procédures explicites (Property) Set et (Property) Get.

Soit la classe MaClasse pour laquelle on veut déclarer les deux propriétés Valeur et Titre.

Façon A : On peut le faire comme suit : Public Valeur As Integer

Public Titre As String

Les autres modules peuvent donc contenir une ou des instances de cette classe.

Dim Un_Objet As MaClasse

…

Un_Objet = New MaClasse()

ou encore en une étape :

Dim Un_Objet As MaClasse = New MaClasse()

et peuvent y référencer comme suit : Un_Objet.Titre = "Voici mon titre"

Tot = Tot + Un_Objet.Valeur

Il n’y a ici aucun contrôle sur l’utilisation que les autres modules feront des propriétés-valeurs de l’objet.

Façon B : On contrôle l’accès à la propriété Valeur pour n’accepter qu’un minimum de 10.

Friend Class MaClasse

Private m_Valeur As Integer

…

Public Property Valeur() As Integer Get

Valeur = m_Valeur ' Ou bien Return m_Valeur End Get

Set(ByVal Value As Integer) ' Ou bien Set et dans ce cas,

If Value < 10 Then ' la variable «Value» est créée automatiquement m_Valeur = 10

Else

m_Valeur = Value End If

End Set End Property End Class

(3)

Cette façon de faire permet de contrôler entièrement l’utilisation «extérieure» de chaque propriété.

Si la propriété n'a pas de section «Get», elle ne peut être lue : elle est en mode écriture seule. Si la section «Set» est absente, la propriété est en mode «lecture seule».

On peut affecter une valeur à une propriété et empêcher qu'elle soit ensuite modifiée (mode

«écriture unique, pour les code de client par exemple).Dès qu'une valeur non nulle est attribuée à la propriété Prop (variable privée m_Prop), toute autre valeur est refusée.:

Private m_Prop As Integer = 0

…

Public Property Prop() As Integer Get

Prop = m_ Prop ' ou bien Return m_Prop End Get

Set(Une_ Prop As Integer) If m_ Prop = 0 Then m_ Prop = Une_ Prop End If

End Set

End Property

End Class

Si la propriété est un tableau, on peut le programmer comme suit :

Private tabItem(100) As Integer

…

Public Default Property Item(ByVal Index As Integer) As Integer Get

Item = tabItem(Index) End Get

Set

tabItem(Index) = Value End Set

End Property

End Class

et l'utiliser comme suit :

Dim Obj As MaClasse = New MaClasse() Dim PG As Integer

Obj.Item(1) = 5 ' ou bien Obj(1) = 5 puisque c'est la propriété de défaut Obj.Item(2) = 20

...

PG = Obj.Item(4)

(4)

Les méthodes

Toute procédure ou fonction publiques définies dans la classe constitue une «méthode» qui peut donc être appelée de l’extérieur. Ici, on définit deux méthodes Doubler et Surface pour notre objet de classe MaClasse. Doubler double la valeur de Valeur jusqu’au maximum de 1000. Surface renvoie la valeur de la surface d’un cercle correspondant à un rayon Valeur.

Public Sub Doubler() m_Valeur = 2 * m_Valeur

if m_Valeur > 1000 then m_Valeur = 1000

End Sub

Public Function Surface() As Double Surface = 3,1416 * m_Valeur * m_Valeur End Function

Les autres modules peuvent donc écrire des choses comme : Un_Objet.Doubler

varSurf = Un_Objet.Surface

La méthode spécifique New est dite le constructeur de la classe et s'exécute au moment de l'instanciation de l'objet. En l'absence de méthode New, les propriétés de l'objet sont créées et les variables sont initialisées à leur valeur de défaut. Le constructeur permet d'établir des valeurs de départ pour les propriétés. Ici, les propriétés Prop1 et Prop2 sont prédéfinies aux valeurs 50 et

"MonNom".

Dim m_Prop1 As Integer, m_Prop2 As String ...

Public Sub New()

m_Prop1 = 50

m_Prop2 = "Gontran Grondin"

End Sub

On peut même définir les valeurs initiales au moment de la création de l'objet en les passant en paramètres lors de l'appel de New.

Dim m_Prop1 As Integer, m_Prop2 As String ...

Public Sub New(ByVal UneValeur As Integer, ByVal UneChaine As String) m_Prop1 = UneValeur

m_Prop2 = UneChaine

End Sub

L'objet sera alors créé comme suit :

Dim UnObjet As MaClasse = New MaClasse(50, "Gontran Grondin")

Et si les propriétés sont en lecture seule (ReadOnly), les valeurs ainsi définies seront ensuite protégées.

(5)

Les événements

Si on veut qu'un objet déclenche un événement, sa classe doit comporter deux éléments : la déclaration de l’événement (nom et, au besoin, un ou des paramètres) et son déclenchement.

Public Event MaximumAtteint()

définit l’événement «MaximumAtteint». Comme pour certains événements d’objets prédéfinis (ex.

Validate) on peut ajouter des paramètres à un événement : Public Event MaximumDépassé(Une_Valeur As Integer)

Pour «déclencher» l’événement, il suffit alors, dans les méthodes de la classe, de programmer l’événement avec l’énoncé RaiseEvent. Par exemple, si on atteint le maximum de Valeur, on veut avertir le programmeur-utilisateur de l’objet :

Public Sub Doubler() m_Valeur = 2 * m_Valeur If m_Valeur > 1000 Then

RaiseEvent MaximumAtteint

m_Valeur = 1000

End If

End Sub

ou par exemple

RaiseEvent MaximumDépassé(m_Valeur)

Dans les modules externes, l’utilisation du mot-clé «WithEvents» dans la déclaration de l'objet:

Dim WithEvents Un_Objet As MaClasse

placera automatiquement dans l’en-tête de la feuille de code, l’objet «Un_Objet» (dans la liste déroulante de gauche) et l’événement «MaximumAtteint» (dans la liste déroulante de droite) permettant au programmeur de programmer la réaction à l’événement en question. Il reste alors au programmeur qui utilise l’objet à réagir ou non à l’événement provoqué en programmant la procédure événementielle adéquate.

Notez cependant que «WithEvents» ne peut coexister ni avec une déclaration d'un tableau de variables, ni avec le mot-clé «New». Dans ce dernier cas, il faut déclarer la variable et la créer plus tard :

Dim WithEvents Obj As MaClasse Obj = New MaClasse()

(6)

Les Collections

Une collection est une structure dont le rôle est semblable à celui d’un tableau à une seule dimension : représenter un groupe d’objets reliés séquentiellement entre eux. Une collection est une classe prédéfinie qui peut contenir un nombre illimité d’objets ou de variables (et même d’autres collections). Ce type d’objet a une constitution très flexible étant donné qu’il peut agir comme conteneur pour tout autre type de variable (sauf pour les types personnalisés définis par l’usager).

Contrairement à un tableau, une même peut contenir des éléments de types différents.

L’architecture d’une collection est très simple. Elle contient seulement trois méthodes : Add, Remove et Item. Elle ne comporte qu’une propriété (Count) et aucun événement. Sa méthode de base (par défaut) est Item.

ATTENTION : contrairement aux tableaux, le dénombrement des items de la collection commence à 1 et non à 0.

La méthode Add

Ajoute un élément dans la collection. Sa syntaxe est la suivante ObjetColl.Add(Élément, [Clé], [Avant], [Après]) Tous les arguments entre crochets sont optionnels.

Élément représente l’élément qu’on veut ajouter dans la collection. Si on utilise uniquement le paramètre Élément, les éléments de la collection seront placés à la queue leu leu et seront traités comme un tableau indexé : ObjetColl.Item(Rang) ou simplement ObjetColl(Rang).

Clé est une clé d’insertion permettant d’identifier de façon unique l’élément inséré. Une clé doit être de type alphanumérique « String » (contenant des caractères), par exemple CStr(NuméroDeLaClé).

Même si la clé est optionnelle, il est fort conseillé de l’utiliser, surtout si on veut travailler avec les paramètres Avant et Après. Car alors, les index des éléments sont modifiés en fonction des ajouts et/ou suppressions des autres éléments de la collection Une façon «standard» d’utiliser un numéro comme clé est la forme suivante :

ObjetColl.Add(Item, "Ident" & Num)

Souvent, les collections contiennent des éléments qui apparaissent et disparaissent constamment.

Leur Index change donc en conséquence La clé reste cependant et permet de repérer l’élément facilement. Si on utilise la clé, on retrouve l’élément en question. Par exemple : variable = ObjetColl("Num18") si telle a été la clé de l’élément recherché. Si l’item "Num18" est devenu le 13^ième de la collection, variable = ObjetColl(13) produira le même effet.

Avant représente la clé (ou l’index) d’un élément qui existe déjà dans la collection. Si on le spécifie, alors Élément va être inséré avant cet élément.

(7)

Après est aussi la clé d’un élément qui existe déjà dans la collection et, dans le cas ou on le spécifie, Élément sera introduit après cet élément. Il est évident qu’on ne peut pas spécifier Avant et Après en même temps. Il ne faut pas oublier cependant d’ajouter une virgule supplémentaire pour utiliser Après.

Pour illustrer l’utilisation d’une collection, considérons les déclarations suivantes :

Dim I as Integer Dim S as String Dim F as clsObjet Dim C as Collection

Dim MaCollection as Collection

I = 1234

S = ”Une chaîne”

F = New clsObjet

C = New Collection

MaCollection = New Collection ' Il faut initialiser la collection avant de l’utiliser Exemple d’utilisation de la méthode Add :

MaCollection.Add(I, ”UnEntier ” & I )

' Ajoute l’entier I dans la collection avec la clé ”UnEntier1234”

MaCollection.Add(S, ”S” , ”UnEntier” & I)

' Ajoute la chaîne S devant I

' Maintenant S est le premier dans la collection

MaCollection.Add(F, F.UniqueIdentifier, , 1)

' Ajoute l’élément F après le premier élément de la collection ' Maintenant F est le deuxième dans la collection

MaCollection.Add(C , ”C” , ”S”)

' Ajoute la collection C devant la chaîne S ' Maintenant C est le premier dans la collection

La collection MaCollection contient maintenant quatre éléments de types différents. L’ordre sera le suivant : C, S, F, I. Notez qu’on insère généralement le même type de données dans une même collection.

La propriété Count

Retourne le nombre d’éléments existants dans la collection. Dans l’exemple précédant, cette propriété retournera la valeur 4 : NoElements = MaCollection.Count

' Maintenant, NoElements = 4

(8)

La méthode Remove

Supprime un élément de la collection. La syntaxe est la suivante :

Objet.Remove(Index)

Index est de type Variant puisqu’il peut représenter un Integer ou un String. Dans le cas où il s’agirait d’un Integer, la collection éliminera l’élément de rang Index. Dans le cas où Index serait de type String, la collection éliminera l’élément ayant la clé Index. Évidemment, si l’élément ayant un tel index n’existe pas dans la collection, on obtient un message d’erreur. Exemple :

MaCollection.Remove(3)

' L’élément avec l’index 3 est enlevé

MaCollection.Remove(”UnEntier1234”) ' L’élément I est enlevé

On peut effacer tous les éléments d’une collection en utilisant une boucle For en éliminer le premier élément :

For J = 1 To MaCollection.Count MaCollection.Remove(1)

' Élimine le premier élément dans la collection Next ' J

La méthode Item

C’est la méthode par défaut d’une collection. Elle retourne un élément qui existe dans la collection.

Puisque Item est la méthode par défaut, on peut l’adresser de deux manières :

MaCollection.Item(Index) Ou

MaCollection(Index)

Dans les deux cas, le résultat est le même. La collection retournera l’élément avec l’index spécifié.

Si cet élément n’existe pas dans la collection, on reçoit un message d’erreur. La valeur Index suit le même principe que la méthode Remove : elle peut donc être soit un entier, soit une chaîne de caractères. Exemple :

Dim J as Integer J = MaCollection.Item(4)

J = MaCollection (”UnEntier1234”) Ce qui affecte la valeur 1234 à J.

(9)

Pour parcourir séquentiellement une collection, on peut utiliser plusieurs méthodes. Les boucles For et For Each peuvent être utiles dans ce cas. En utilisant ce type de boucle, on peut parcourir les éléments de la collection par leur index, soit en utilisant un objet du même type que les éléments dans la collection. Par exemple considérons une collection composée d’objets de la classe clsObjet possédant une propriété entière Valeur. Pour la parcourir on peut faire :

Dim I As Integer, Total As Integer Dim UnObjet As clsObjet

For I = 1 To MaCollection.Count UnObjet = MaCollection(I) Total = Total + UnObjet.Valeur Next 'I

Ou encore :

For Each UnObjet In MaCollection Total = Total + UnObjet.Valeur Next

Dans les deux cas l’effet sera le même. La décision d’utiliser l’une ou l’autre dépend du contexte dans lequel on l’utilise.