09 visual basic .net - modules de classes-constructeurs, encapsulation, heritage et polymorphisme

Microsoft Visual Basic .NET
 Découverte du nouvel environnement Visual
Studio .NET
 Eléments du langage Visual Basic .NET
 Etude et mise en œuvre des fonctionnalités
du nouveau Framework .NET
 Programmation orientée objet et
développement de composants
réutilisables
 Accès aux données avec ADO .NET
Professeur: Hamza SAID
1

Programmation orientée objet et
développement de composants réutilisables
 Modules de classes :
constructeurs,
encapsulation, héritage et
polymorphisme
 Composants réutilisables :
création d’un contrôle
utilisateur
2

Points abordés :
• La POO (Programmation Orientée Objet)
• les modules de classe
• Les procédures Property
• Membres Partagées
• Le mécanisme de surcharge
• Les notions de Constructeurs et Destructeurs
• L'Héritage
• Le Polymorphisme
• la notion d‘Interface
Modules de classes : constructeurs,
encapsulation, héritage et polymorphisme
3
Programmation orientée objet et
développement de composants réutilisables

• Quel que soit le langage employé, la programmation orientée
objet repose sur trois concepts fondamentaux :
• L'encapsulation
• L'héritage
• Le polymorphisme
• Les versions 5 et 6 de Visual Basic autorisaient une certaine
forme de polymorphisme basé sur l'implémentation de différents
interfaces au sein d'un même objet, mais pas l'héritage.
• La version .NET hisse Visual Basic au même rang que les
langages C++ et Java en supportant pleinement ces deux
concepts.
La POO (Programmation Orientée Objet)
4

• Définitions:
• Un objet est une combinaison de code et de données. Ceci forme ce que l'on appelle
« l'implémentation de l'objet »
• L'interface d'un objet représente l'ensemble de ses membres.
• L'encapsulation est un mécanisme dont le rôle consiste à
isoler l'implémentation de l'objet de son interface vis-à-vis
des applications clientes qui utilisent l'objet.
• L'encapsulation permet aussi d'exposer l'interface d'un
objet à des applications clientes, sans qu'elles aient à se
préoccuper du fonctionnement interne (l'implémentation)
des membres invoquées
L'encapsulation5

• Ceci nous conduit à considérer la conception d'un objet
en deux étapes :
• La définition de son interface : qui est un contrat entre l'objet et ses applications
clientes
• Son implémentation : peut être modifiée sans conséquence
L'encapsulation6

• Une classe (Class) est la définition d'un objet de tous
les jours.
• Une classe déclare des propriétés communes à un
ensemble d'objets:
• Des attributs (variables, constantes…) représentant l'état des objets et des
méthodes (procédures) représentant leur comportement
• Exemple:
• Il est possible de définir une classe « Humain » afin de modéliser tous les êtres
humains, et une nommée « Chien » pour représenter les chiens.
Les modules de classe7

• Voici l'instruction de déclaration d'un espace de noms nommé « Animaux » et
« chien » est une classe appartenant à cet espace de nom :
Les modules de classe -Exemple8
Namespace Animaux
Public Class Chien
Public Sub Aboie()
Console.Writeline("Le chien aboie !")
End Sub
End Class
End Namespace

• Un objet est une instance de classe.
• Par exemple, « Jimmy » est un objet de type « Chien ».
• Pour illustrer ceci, nous allons créer un objet issu de la classe « Chien »
Les Objets (instance de classe)9
Les modules de classe
Private Sub MaProc()
'Voici comment déclarer une variable nommée Jimmy, de type Chien :
'Nous spécifions Animaux.Chien car la classe Chien fait partie de
'l'espace de Nom Animaux (cf. plus haut)
Dim Jimmy As Animaux.Chien
'Crée l'objet.
Jimmy = New Animaux.Chien()
'Voici une autre manière de créer un objet :
'Dim Jimmy as New Chien
'Appel de la fonction principale de Jimmy
Jimmy.Aboie()
End Sub

• Pour gérer les données de vos objets, vous avez le
choix entre des champs ou des propriétés.
• Alors que les champs sont de simples variables
publiques, les propriétés utilisent des procédures pour
encadrer la lecture et la mise à jour des données (une
forme d'encapsulation)
• Ce sont les mots-clés « Get » (lecture) et « Set » (mise
à jour) qui sont utilisés pour la déclaration de ces
procédures.
Les procédures Property10

Les procédures Property
Exemple : Déclaration d’une propriété « Age »
11
Class Chien
'Utilisons une variable privée pour l'âge :
Private mAgeDuChien As Integer
Public Property Age() As Integer
'Lecture de l'âge :
Get
Console.WriteLine("Getting Property")
Return mAgeDuChien
End Get
'MAJ de l'âge :
Set(ByVal Value As Integer)
Console.WriteLine("Setting Property")
mAgeDuChien = Value
End Set
End Property
Public Sub Aboie()
Console.WriteLine("Le chien aboie !")
End Sub
End Class

Exemple : Déclaration d’une propriété « Age »
12
Class Chien
'Utilisons une variable privée pour l'âge :
Private mAgeDuChien As Integer
Public Property Age() As Integer
'Lecture de l'âge :
Get
Console.WriteLine("Getting Property")
Return mAgeDuChien
End Get
'MAJ de l'âge :
Set(ByVal Value As Integer)
Console.WriteLine("Setting Property")
mAgeDuChien = Value
End Set
End Property
Public Sub Aboie()
End Sub
End Class
Déclaration de la
propriété « Age »
« Get » permet de
retourner une valeur
« Set » permet de
mettre à jour une valeur

Exemple : Utilisation de la propriété « Age »
13
'Créons un objet :
Jimmy = New Animaux.Chien
'Nous ne pouvons accéder directement à la variable mAgeDuChien car elle est Private,
'nous devons utiliser la procédure Age().
'Affectons-lui une valeur. La procédure Set Age sera mise à contribution :
Jimmy.Age = 30
'Récupérons maintenant cette valeur :
'c'est au tour de la procédure Get Age de travailler :
Dim curAge = Jimmy.Age()
End Sub

Exemple : Utilisation de la propriété « Age »
14
'Créons un objet :
Jimmy = New Animaux.Chien
'Nous ne pouvons accéder directement à la variable mAgeDuChien car elle est Private,
'nous devons utiliser la procédure Age().
'Affectons-lui une valeur. La procédure Set Age sera mise à contribution :
Jimmy.Age = 30
'Récupérons maintenant cette valeur :
'c'est au tour de la procédure Get Age de travailler :
Dim curAge = Jimmy.Age()
End Sub
La procédure Set
Age sera utilisée
La procédure Get
Age sera utilisée

• Ils sont aussi appelés « membres statiques »
• Les membres partagés (propriétés et méthodes) peuvent
être appelés directement, sans passer par l'instanciation
d'un objet.
• Le mot-clé « Shared » indique un membre partagé
• Une propriété « Shared » contient quant à elle une valeur
commune à tous les objets d'une classe.
• Ex.: La procédure « WriteLine() » que nous utilisons depuis
le début de ce cours est une méthode partagée de la
classe Console.
Les membres partagées15

Les membres partagées
Exemple : Déclaration de membres partagés
16
Class Chien
'Aboie est maintenant une fonction Public et Shared de cette classe
Public Shared Sub Aboie()
End Sub
'Marche, quant à elle, est une fonction Public, mais non partagée.
Public Sub Marche()
Console.WriteLine("Le chien marche ...")
End Sub
End Class
La procédure « Aboie »
est maintenant un
membre partagé

Les membres partagées
Exemple : Utilisation du membre partagé de la classe Chien
17
'Nous pouvons faire appel à la méthode Aboie() directement,
'Sans passer par la création d'un objet de type Chien,
'puisque qu'elle est partagée
Animaux.Chien.Aboie()
'Par contre, nous ne pourrons utiliser la méthode Marche()
'que suite à la création d'un objet, puisque celle-ci
'n'est pas partagée.
Jimmy = New Animaux.Chien()
Jimmy.Marche()
End Sub
Utilisation de la
procédure « Aboie »
sans instanciation

• La surcharge est une technique simple à utiliser, qui permet d'utiliser le
même nom de fonction avec des paramètres de différents types.
• Le mot clé « Overloads » permet de faire une surcharge
• Voyons ce que ça donne sur la classe « Addition » dans l'exemple qui
suit :
Le mécanisme de surcharge18
Class Addition
'additionne 2 entiers
Public Overloads Sub Add(ByVal A As Integer, ByVal B As Integer)
Console.Writeline("Adding Integers: " + Convert.ToString(a + b))
End Sub
'concatène 2 chaînes de caractères
Public Overloads Sub Add(ByVal A As String, ByVal B As String)
Console.Writeline("Adding Strings: " + a + b)
End Sub
End Class
Les 2
procédures ont
le même nom
« Add » grâce
au mot clé
« Overloads »

• Utilisation de l’exemple précédent:
Le mécanisme de surcharge19
Dim monCalcul As Addition
'Créée l'objet
monCalcul = New Addition
'Appel de la première fonction ...
'Affiche (Adding Integers: 30)
monCalcul.Add(10, 20)
' ... et appel de la seconde :
'Affiche (Adding Strings: Bonjour comment allez-vous ?)
monCalcul.Add("Bonjour", " comment allez-vous ?")
End Sub

1. La notion de constructeur d’un objet
2. La notion de destructeur d’un objet
Constructeurs et Destructeurs20

• Un constructeur (Constructor) est une procédure
spéciale qui est automatiquement exécutée quand un
objet est créé.
• Une telle procédure se nomme New().
• Les constructeurs peuvent faire l'objet de surcharge
mais contrairement aux autres méthodes, le mot clé
Overloads n'est pas requis.
Notion de constructeur21
Constructeurs et Destructeurs

• Par opposition, un destructeur (Destructor) est une
procédure qui est automatiquement exécutée à la mort
de l'objet.
• Une telle procédure se nomme Finalize().
• Note: un destructeur n’est exécuté qu’au passage du
« Garbage Collector »
Notion de destructeur22

Exemple23
Public Class Chien
'La variable age
Private Age As Integer
Public Sub New()
Console.WriteLine("Un chien est né")
Age = 0
End Sub
Public Sub New(ByVal val As Integer)
Console.WriteLine("Nouveau chien dont l'âge est " + Convert.ToString(val))
Age = val
End Sub
Protected Overrides Sub Finalize()
Console.WriteLine("Paf le chien ... (désolé)")
End Sub
End Class
2
constructeurs
en surcharge
Un destructeur

• L'héritage est un mécanisme par lequel une classe
dérivée (ou classe fille) hérite de toutes les
caractéristiques de sa classe de base (ou classe mère).
• Il est possible de créer via héritage vos classes à partir
d'une classe existante: Il suffit pour cela d'utiliser le
mot-clé « Inherits ».
L‘héritage24

• Voici notre classe de base :
L‘héritage
Exemple : Classe de base
25
Public Class Humain
'Quelque chose que la plupart des êtres humains font :
Public Sub Marche()
Console.WriteLine("Je marche ...")
End Sub
End Class
• Voici notre classe fille nommée « Developpeur » :
Public Class Developpeur
Inherits Humain
'Nous avons donc déjà accès à la méthode Marche() définie ci-dessus
'Et voici une autre qui illustre ce que certains programmeurs font parfois :
Public Sub PiqueDuCode()
Console.WriteLine("Je pompe du code ...")
End Sub
End Class
Le mot clé
« Inherits » permet
d’hériter de la
classe mère
« Humain »

• On peut maintenant appeler la procédure Marche à partir d'un objet de type
Developpeur
L‘héritage
Exemple : Classe de base
26
Dim Tom as Developpeur
Tom = New Developpeur
'Cet appel est valide puisque Developpeur a accès à cette fonction
'héritée de la classe Humain :
Tom.Marche()
'Celui-ci également puisque Tom est une instance de la classe Developpeur
Tom.PiqueDuCode()
End Sub
« Marche »
appartient à la
classe mère

• « MustInherit » doit être placé avant la déclaration de la classe
• Ce mot clé indique qu'une classe ne peut être instanciée
• Qu'elle ne peut donc être utilisée que comme une classe de
base.
• Une classe définie avec le mot clé « MustInherit » se nomme
une « classe abstraite »
• Exemples:
• Si vous déclarez la classe Humain en tant que « MustInherit Humain », alors vous ne pourrez pas
créer d'objets de type « Humain » à partir de cette classe, mais seulement à partir de classes
dérivées.
• La classe Stream : On ne peut instancier que ses classes filles « StreamReader » et
« StreamWriter »
Le mot clé « MustInherit »27
L‘héritage

Le mot clé « MustInherit » - Exemple28
L‘héritage
Public MustInherit Class Humain
Public Sub Marche()
End Sub
End Class

• À l'inverse, ce mot-clé indique que cette classe ne peut
pas être héritée, c'est-à-dire servir de classe de base.
• Exemple:
• Si vous déclarez la classe « Humain » en tant que « NotInheritable Humain »,
aucune classe dérivée ne pourra lui être créée.
Le mot clé « NotInheritable »29
L‘héritage

Le mot clé « NotInheritable » - Exemple
30
L‘héritage
Public NotInheritable Class Humain
Public Sub Marche()
End Sub
End Class

• Par défaut, une classe dérivée hérite des méthodes de sa
classe de base. Mais si une propriété ou une méthode doit
avoir un comportement différent dans la classe fille, elle
doit y être redéfinie !
• En fait, il suffit de définir une nouvelle implémentation de la
méthode dans la classe dérivée
• Le mot-clé « Overridable » est utilisé pour préciser qu'une
méthode peut être redéfinie,
• et le mot-clé « Overrides » est quant à lui utilisé pour
indiquer quelles méthodes sont redéfinies.
La redéfinition d’un membre31
L‘héritage

La redéfinition d’un membre - Exemple32
L‘héritage
Public Class Humain
'Parle() est redéfinissable :
Public Overridable Sub Parle()
Console.WriteLine("Je parle")
End Sub
End Class
Maintenant, créons une classe dérivée de « Humain » :
Public Class Indien
Inherits Humain
'Notre Indien parle l'Hindi, la langue nationale en Inde
'la méthode Parle() qui suit, redéfinit la méthode Parle() de la classe de base (Humain)
Public Overrides Sub Parle()
Console.WriteLine("Je parle Hindou")
End Sub
End Class
Voici notre classe de base :

La redéfinition d’un membre - Exemple33
L‘héritage
Exemple pour tester nos classes:
'Tom est un humain
Dim Tom As Humain
Tom = New Humain
'Tony est humain, et plus précisément Indien
Dim Tony As Indien
Tony = New Indien
'Voici un appel à la méthode Parle() de la classe Humain :
'Affiche: Je parle
Tom.Parle()
'Et un appel de la méthode Parle() de la classe Indien
'Affiche: Je parle Hindou
Tony.Parle()
End Sub

De même:
• « MustOverride »
• Indique qu'une méthode doit être redéfinie pour chaque classe fille.
• Exemple: si dans la classe « Humain », vous déclarez la méthode « Parle » en tant que
« MustOverride Parle », chacune des classes filles devra redéfinir cette méthode.
• « NotOverridable »
• Définit par défaut pour toutes les méthodes qui ne redéfinissent aucune autre méthode
• À l'inverse, ce mot-clé indique que cette procédure ne peut être redéfinie dans une classe fille.
• NotOverridable ne peut être utilisée que par des méthodes qui redéfinissent d’autres méthodes
seulement
• Exemple: si dans la classe « Indien », vous déclarez la méthode « Parle » en tant que
« NotOverridable Overrides Sub Parle », aucune classe fille de la classe « Indien » ne pourra
redéfinir cette méthode.
La redéfinition d’un membre34
L‘héritage

• Le polymorphisme est un mécanisme via lequel un objet
peut prendre plus d'une forme.
• Exemple :
• Si vous avez une classe de base nommée « Humain », un objet de type « Humain »
peut être utilisé pour contenir un objet de n'importe laquelle de ses classes
dérivées. Quand vous appelez une méthode à partir de votre objet, le système
déterminera automatiquement le type de l'objet afin d'appeler la fonction
appropriée.
Le Polymorphisme35

Le Polymorphisme - Exemple36
Prenons notre exemple précédent:
Public Class Humain
'Parle() peut être redéfinie :
Public Overridable Sub Parle()
Console.WriteLine("Je parle")
End Sub
End Class
Public Class Indien
Inherits Humain
'Notre Indien parle l'Hindi, la langue nationale en Inde
'la méthode Parle() qui suit redéfinit la méthode Parle() de la classe de base (Humain)
Public Overrides Sub Parle()
Console.WriteLine("Je parle Hindou")
End Sub
End Class

À l'intérieur d'une procédure, ajoutons ce qui suit:
'Tom est un humain (classe de base)
Dim Tom As Humain
'Affectons-lui une variable de la classe fille Indien
Tom = New Indien
'Cette affectation est correcte, car la classe Indien
'est fille de la classe Humain.
'Puis faisons appel à la méthode Parle comme ceci :
Tom.Parle()
End Sub
Tom est une variable de
type « Humain » mais on
lui affecte un objet de
type « Indien »
La méthode « Parle » de
la classe « Indien » est
appelée

À l'intérieur d'une procédure, ajoutons ce qui suit:
'Tom est un humain (classe de base)
Dim Tom As Humain
'Affectons-lui une variable de la classe fille Indien
Tom = New Indien
'Cette affectation est correcte, car la classe Indien
'est fille de la classe Humain.
'Puis faisons appel à la méthode Parle comme ceci :
Tom.Parle()
End Sub
Tom est une variable de
type « Humain » mais on
lui affecte un objet de
type « Indien »
La méthode « Parle » de
la classe « Indien » est
appelée
Ceci parce que, comme la plupart des langages orientés
objet, Vb.NET peut automatiquement détecter le type de
l'objet assigné à la variable appartenant à la classe de
base : c'est ce que l'on appelle le Polymorphisme.

• Une interface est une classe qui contient simplement la
définition de ses membres, mais par leur implémentation.
• Elle se définit comme une Class dans laquelle le mot
« Classe » doit être remplacé par « Interface ».
La notion d'interface39

Exemple d'interface:
La notion d'interface - Exemple40
Public Interface Multimedia
Property Titre() As String
Sub Lecture()
End Interface

Exemple d'interface:
La notion d'interface - Exemple41
Public Interface Multimedia
Property Titre() As String
Sub Lecture()
End Interface
Exemple de classe qui implémente l'interface « Multimedia »
Public Class CDAudio
Implements Multimedia
Private m_titre As String
Public Sub Lecture() Implements Multimedia.Lecture
'Lancer le lecteur Audio pour écouter m_titre
MsgBox("Lecture audio de " & m_titre & " au format " & FormatAudio)
End Sub
Public Property Titre As String Implements Multimedia.Titre
Get
Return m_titre
End Get
Set(ByVal value As String)
m_titre = value
End Set
End Property
'Membres spécifiques à la classe
Public FormatAudio As String
End Class

• Trois mécanismes au cœur de la programmation orientée
objet : l'encapsulation, l'héritage et le polymorphisme
• Les modules de classe
• Les procédures « Property »
• Les membres partagés (statiques)
• Le mécanisme de surcharge
• La redéfinition d’un membre
• Les constructeurs et destructeurs
• Les interfaces
En Bref42

09 visual basic .net - modules de classes-constructeurs, encapsulation, heritage et polymorphisme

Contenu connexe

Tendances

Similaire à 09 visual basic .net - modules de classes-constructeurs, encapsulation, heritage et polymorphisme

Plus de Hamza SAID

Dernier

09 visual basic .net - modules de classes-constructeurs, encapsulation, heritage et polymorphisme