Implémente l’instruction
Spécifie une interface ou une classe qui sera implémentée dans le module de classe dans lequel elle apparaît.
Syntaxe
Implémente [ Classe InterfaceName | ]
Les paramètres obligatoires InterfaceName ou Class représentent les noms d'une interface ou d'une classe dans une bibliothèque de types dont les méthodes seront implémentées par les méthodes correspondantes dans la classe Visual Basic.
Remarques
Une interface est une collection de prototypes représentant les membres (méthodes et propriétés) que l’interface encapsule ; autrement dit, il contient uniquement les déclarations pour les procédures membres. Une classe fournit une implémentation de toutes les méthodes et propriétés d’une ou plusieurs interfaces. Les classes fournissent le code utilisé lorsque chaque fonction est appelée par un contrôleur de la classe. Toutes les classes implémentent au moins une interface, considérée comme l'interface par défaut de la classe. Dans Visual Basic, un membre n'appartenant pas explicitement à une interface implémentée est implicitement un membre de l'interface par défaut.
Lorsqu’une classe Visual Basic implémente une interface, la classe Visual Basic fournit ses propres versions de toutes les procéduresPublic spécifiées dans la bibliothèque de types de l’interface. Outre le mappage qu'elle assure entre les prototypes de l'interface et vos procédures, l'instruction Implements force la classe à accepter les appels QueryInterface sur le composant COM pour l'ID d'interface spécifié.
Remarque
Visual Basic n'implémente pas les interfaces ni les classes dérivées.
Lorsque vous implémentez une interface ou une classe, vous devez inclure toutes les procédures Public concernées. Si un membre est absent de l'implémentation d'une interface ou d'une classe, une erreur se produit. Si vous n'insérez pas de code dans l'une des procédures d'une classe que vous implémentez, vous pouvez générer l'erreur appropriée (Const E_NOTIMPL = &H80004001) pour qu'un utilisateur de l'implémentation comprenne qu'un membre n'est pas implémenté.
L'instruction Implements ne peut pas apparaître dans un module standard.
Exemple
L'exemple suivant illustre l'utilisation de l'instruction Implements pour permettre à plusieurs classes d'accéder à un jeu de déclarations. En partageant les déclarations via l'instruction Implements, aucune des classes n'a besoin de faire de déclarations. L’exemple montre également comment l’utilisation d’une interface permet l’abstraction : une variable fortement de type peut être déclarée à l’aide du type d’interface. Des objets de différents types de classe qui implémentent l’interface peuvent ensuite lui être attribués.
Supposons qu’il existe deux formulaires , SelectorForm et DataEntryForm. Le formulaire de sélection comporte deux boutons : Données client et Données du fournisseur. Pour entrer le nom et l’adresse d’un client ou d’un fournisseur, l’utilisateur clique sur le bouton client ou le bouton fournisseur du formulaire de sélection, puis entre le nom et l’adresse à l’aide du formulaire de saisie de données. Le formulaire de saisie de données comporte deux champs de texte, Nom et Adresse.
Le code suivant pour les déclarations d’interface se trouve dans une classe appelée PersonalData :
Public Name As String
Public Address As String
Le code qui prend en charge les données client se trouve dans un module de classe appelé Client. Notez que l’interface PersonalData est implémentée avec des membres nommés avec le nom PersonalData_ de l’interface comme préfixe.
Implements PersonalData
'For PersonalData implementation
Private m_name As String
Private m_address As String
'Customer specific
Public CustomerAgentId As Long
'PersonalData implementation
Private Property Let PersonalData_Name(ByVal RHS As String)
m_name = RHS
End Property
Private Property Get PersonalData_Name() As String
PersonalData_Name = m_name
End Property
Private Property Let PersonalData_Address(ByVal RHS As String)
m_address = RHS
End Property
Private Property Get PersonalData_Address() As String
PersonalData_Address = m_address
End Property
'nitialize members
Private Sub Class_Initialize()
m_name = "[customer name]"
m_address = "[customer address]"
CustomerAgentID = 0
End Sub
Le code qui prend en charge les données du fournisseur se trouve dans un module de classe appelé Supplier :
Implements PersonalData
'for PersonalData implementation
Private m_name As String
Private m_address As String
'Supplier specific
Public NumberOfProductLines As Long
'PersonalData implementation
Private Property Let PersonalData_Name(ByVal RHS As String)
m_name = RHS
End Property
Private Property Get PersonalData_Name() As String
PersonalData_Name = m_name
End Property
Private Property Let PersonalData_Address(ByVal RHS As String)
m_address = RHS
End Property
Private Property Get PersonalData_Address() As String
PersonalData_Address = m_address
End Property
'initialize members
Private Sub Class_Initialize()
m_name = "[supplier name]"
m_address = "[supplier address]"
NumberOfProductLines = 15
End Sub
Le code suivant prend en charge le formulaire Sélecteur :
Private cust As New Customer
Private sup As New Supplier
Private Sub Customer_Click()
Dim frm As New DataEntryForm
Set frm.PD = cust
frm.Show 1
End Sub
Private Sub Supplier_Click()
Dim frm As New DataEntryForm
Set frm.PD = sup
frm.Show 1
End Sub
Le code suivant prend en charge le formulaire d’entrée de données :
Private m_pd As PersonalData
Private Sub SetTextFields()
With m_pd
Text1 = .Name
Text2 = .Address
End With
End Sub
Public Property Set PD(Data As PersonalData)
Set m_pd = Data
SetTextFields
End Property
Private Sub Text1_Change()
m_pd.Name = Text1.Text
End Sub
Private Sub Text2_Change()
m_pd.Address = Text2.Text
End Sub
Notez que, dans le formulaire d’entrée de données, la variable m_ est déclarée à l’aide de l’interface PersonalData et qu’elle peut être affectée à des objets de la classe Customer ou Supplier , car les deux classes implémentent l’interface PersonalData.
Notez également que la variable m_ peut uniquement accéder aux membres de l’interface PersonalData. Si un objet Customer lui est affecté, le membre CustomerAgentId spécifique n’est pas disponible. De même, si un objet Supplier lui est attribué, le membre spécifique NumberOfProductLines n’est pas disponible. L’affectation d’un objet à des variables déclarées à l’aide de différentes interfaces fournit un comportement polymorphe.
Notez également que les classes Customer et Supplier , telles que définies précédemment, n’exposent pas les membres de l’interface PersonalData. La seule façon d’accéder aux membres PersonalData consiste à affecter un objet Customer ou Supplier à une variable déclarée comme PersonalData. Si un comportement de type héritage est souhaité, avec la classe Customer ou Supplier exposant les membres PersonalData, des membres publics doivent être ajoutés à la classe . Ceux-ci peuvent être implémentés en déléguant aux implémentations de l’interface PersonalData.
Par exemple, la classe Customer peut être étendue avec les éléments suivants :
'emulate PersonalData inheritance
Public Property Let Name(ByVal RHS As String)
PersonalData_Name = RHS
End Property
Public Property Get Name() As String
Name = PersonalData_Name
End Property
Public Property Let Address(ByVal RHS As String)
PersonalData_Address = RHS
End Property
Public Property Get Address() As String
Address = PersonalData_Address
End Property
Voir aussi
Assistance et commentaires
Avez-vous des questions ou des commentaires sur Office VBA ou sur cette documentation ? Consultez la rubrique concernant l’assistance pour Office VBA et l’envoi de commentaires afin d’obtenir des instructions pour recevoir une assistance et envoyer vos commentaires.