Implémente l’instruction

Article
04/07/2023

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_pd 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_pd 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.