Programmation orientée objet (Visual Basic)

Visual Basic offre une prise en charge complète de la programmation orientée objet, y compris l’encapsulation, l’héritage et le polymorphisme.

L’encapsulation signifie qu’un groupe de propriétés, méthodes et autres membres corrélés est traité comme une unité ou un objet unique.

L’héritage décrit la possibilité de créer des classes à partir d’une classe existante.

Le polymorphisme signifie que plusieurs classes peuvent être utilisées de manière interchangeable, même si chacune des classes implémente les mêmes propriétés ou méthodes de manière différente.

Cette section décrit les concepts suivants :

• Classes et objets
  • Membres de classe
    • Propriétés et champs
    • Méthodes
    • Constructeurs
    • Destructeurs
    • Événements
    • Classes imbriquées
  • Modificateurs d’accès et niveaux d’accès
    • Instanciation de classes
    • Classes et membres partagés
    • Types anonymes
• Héritage
  • Remplacement de membres
• Interfaces
• Génériques
• Délégués

Classes et objets

Les termes classe et objet sont parfois employés indifféremment, mais en réalité, les classes décrivent le type des objets, alors que les objets sont des instances utilisables des classes. Cela explique pourquoi l’opération de création d’un objet est appelée instanciation. Si l'on reprend l'analogie avec un plan de construction, une classe est un plan, et un objet est un bâtiment construit à partir de ce plan.

Pour définir une classe :

Class SampleClass
End Class

Visual Basic fournit également une version basique de classes, appelée structures, qui sont utiles pour créer un grand tableau d’objets sans utiliser trop de mémoire pour cette opération.

Pour définir une structure :

Structure SampleStructure
End Structure

Pour plus d'informations, consultez les pages suivantes :

• Class (instruction)
• Structure, instruction

Membres de classe

Chaque classe peut avoir différents membres de classe : des propriétés qui décrivent les données de classe, des méthodes qui définissent le comportement de classe et des événements qui permettent la communication entre les différents objets et classes.

Propriétés et champs

Les propriétés et les champs sont des informations contenues dans un objet. Les champs sont similaires aux variables, car ils peuvent être lus ou définis directement.

Pour définir un champ :

Class SampleClass
    Public SampleField As String
End Class

Les propriétés comportent des procédures Get et Set qui apportent davantage de contrôle sur le mode de définition ou de retour des valeurs.

Visual Basic vous permet de créer un champ privé pour stocker la valeur de propriété ou d’utiliser des propriétés implémentées automatiquement qui créent ce champ automatiquement en arrière-plan et fournissent la logique de base pour les procédures de propriété.

Pour définir une propriété implémentée automatiquement :

Class SampleClass
    Public Property SampleProperty as String
End Class

Si vous devez exécuter des opérations supplémentaires pour la lecture et l'écriture de la valeur de propriété, définissez un champ pour le stockage de la valeur de propriété et fournissez la logique de base pour son stockage et son extraction :

Class SampleClass
    Private m_Sample As String
    Public Property Sample() As String
        Get
            ' Return the value stored in the field.
            Return m_Sample
        End Get
        Set(ByVal Value As String)
            ' Store the value in the field.
            m_Sample = Value
        End Set
    End Property
End Class

La plupart des propriétés disposent de méthodes ou de procédures destinées à la fois à définir et à obtenir la valeur de propriété. Toutefois, vous pouvez créer des propriétés en lecture seule ou en écriture seule pour empêcher qu'elles soient modifiées ou lues. En Visual Basic, vous pouvez utiliser les mots clés ReadOnly et WriteOnly. Toutefois, les propriétés implémentées automatiquement ne peuvent pas être en lecture seule ou en écriture seule.

Pour plus d’informations, consultez l’article suivant :

• Property Statement
• Get, instruction
• Set (instruction)
• Lecture seule
• WriteOnly

Méthodes

Une méthode est une action que peut effectuer un objet.

Pour définir une méthode de classe :

Class SampleClass
    Public Function SampleFunc(ByVal SampleParam As String)
        ' Add code here
    End Function
End Class

Une classe peut avoir plusieurs implémentations, ou surcharges, de la même méthode qui diffèrent du point de vue du nombre de paramètres ou des types de paramètres.

Pour surcharger une méthode :

Overloads Sub Display(ByVal theChar As Char)
    ' Add code that displays Char data.
End Sub
Overloads Sub Display(ByVal theInteger As Integer)
    ' Add code that displays Integer data.
End Sub

Dans la plupart des cas, vous déclarez une méthode dans une définition de classe. Toutefois, Visual Basic prend également en charge des méthodes d’extension, qui vous permettent d’ajouter des méthodes à une classe existante hors de la définition réelle de la classe.

Pour plus d'informations, consultez les pages suivantes :

• Function (instruction)
• Sub (instruction)
• Surcharges
• Méthodes d’extension

Constructeurs

Les constructeurs sont des méthodes de classe qui s'exécutent automatiquement lorsqu'un objet d'un type donné est créé. Les constructeurs initialisent habituellement les données membres du nouvel objet. Un constructeur ne peut s'exécuter qu'une seule fois lorsqu'une classe est créée. En outre, le code figurant dans le constructeur s'exécute toujours avant tout autre code dans une classe. Toutefois, vous pouvez créer plusieurs surcharges de constructeur de la même façon que vous le faites pour toute autre méthode.

Pour définir un constructeur pour une classe :

Class SampleClass
    Sub New(ByVal s As String)
        // Add code here.
    End Sub
End Class

Pour plus d’informations, consultez Durée de vie d’un objet : création et destruction des objets.

Destructeurs

Les destructeurs permettent de détruire les instances des classes. Dans le .NET Framework, le garbage collector gère automatiquement l'allocation et la libération de mémoire pour les objets managés figurant dans votre application. Toutefois, vous pouvez avoir besoin de destructeurs pour nettoyer toutes les ressources non managées créées par votre application. Il ne peut y avoir qu'un seul destructeur pour une même classe.

Pour plus d’informations sur les destructeurs et l’opération de garbage collection dans le .NET Framework, consultez Garbage collection.

Événements

Les événements permettent à une classe ou un objet de notifier d'autres classes ou objets lorsqu'une situation intéressante se produit. La classe qui envoie (ou déclenche) l’événement est appelée éditeur et les classes qui reçoivent (ou gèrent) l’événement sont appelées abonnés. Pour plus d’informations sur les événements, leur déclenchement et leur gestion, consultez Événements.

• Pour déclarer des événements, utilisez l’instruction Event.

• Pour lever des événements, utilisez l’instruction RaiseEvent.

• Pour spécifier des gestionnaires d’événements à l’aide d’une méthode déclarative, utilisez l’instruction WithEvents et la clause Handles.

• Pour pouvoir ajouter, supprimer et modifier dynamiquement le gestionnaire d’événements associé à un événement, utilisez l’instruction AddHandler et l’instruction RemoveHandler avec l’opérateur AddressOf.

Classes imbriquées

Une classe définie à l’intérieur d’une autre classe est dite imbriquée. Par défaut, une classe imbriquée est privée.

Class Container
    Class Nested
    ' Add code here.
    End Class
End Class

Pour créer une instance de la classe imbriquée, utilisez le nom de la classe de conteneur suivi d'un point, puis du nom de la classe imbriquée :

Dim nestedInstance As Container.Nested = New Container.Nested()

Modificateurs d’accès et niveaux d’accès

Toutes les classes et tous les membres de classe peuvent spécifier le niveau d’accès qu’ils fournissent aux autres classes à l’aide des modificateurs d’accès.

Les modificateurs d’accès suivants sont disponibles :

Pour plus d’informations, consultez Niveaux d’accès en Visual Basic.

Instanciation de classes

Pour créer un objet, vous devez instancier une classe ou créer une instance de classe.

Dim sampleObject as New SampleClass()

Après avoir instancié une classe, vous pouvez assigner des valeurs aux propriétés et champs de l'instance et appeler des méthodes de classe.

' Set a property value.
sampleObject.SampleProperty = "Sample String"
' Call a method.
sampleObject.SampleMethod()

Pour assigner des valeurs aux propriétés pendant le processus d'instanciation de la classe, utilisez des initialiseurs d'objets :

Dim sampleObject = New SampleClass With
    {.FirstProperty = "A", .SecondProperty = "B"}

Pour plus d'informations, consultez les pages suivantes :

• Nouvel opérateur
• Initialiseurs d'objets : types nommés et anonymes

Classes et membres partagés

Un membre partagé de la classe est une propriété, une procédure ou un champ que toutes les instances d’une classe partagent.

Pour définir un membre partagé :

Class SampleClass
    Public Shared SampleString As String = "Sample String"
End Class

Pour accéder au membre partagé, utilisez le nom de la classe sans créer d’objet de cette classe :

MsgBox(SampleClass.SampleString)

Les modules partagés en Visual Basic comportent des membres statiques (partagés) uniquement et ne peuvent pas être instanciés. Les membres partagés ne peuvent pas également accéder aux propriétés, champs ou méthodes non partagés

Pour plus d'informations, consultez les pages suivantes :

• Partagé
• Module, instruction

Types anonymes

Les types anonymes vous permettent de créer des objets sans écrire de définition de classe pour le type de données. À la place, le compilateur se charge de générer une classe. La classe ne possède pas de nom utilisable et contient les propriétés que vous spécifiez lors de la déclaration de l'objet.

Pour créer une instance de type anonyme :

' sampleObject is an instance of a simple anonymous type.
Dim sampleObject =
    New With {Key .FirstProperty = "A", .SecondProperty = "B"}

Pour plus d’informations, consultez Types anonymes.

Héritage

Il vous permet de créer une nouvelle classe qui réutilise, étend et modifie le comportement défini dans une autre classe. La classe dont les membres sont hérités porte le nom de classe de base et la classe qui hérite de ces membres porte le nom de classe dérivée. Toutefois, toutes les classes dans Visual Basic héritent implicitement de la classe Object qui prend en charge la hiérarchie de classes .NET et fournit des services de bas niveau à toutes les classes.

Pour hériter d'une classe de base :

Class DerivedClass
    Inherits BaseClass
End Class

Par défaut, toutes les classes peuvent être héritées. Toutefois, vous pouvez spécifier si une classe ne doit pas être utilisée comme classe de base ou créer une classe qui peut être utilisée uniquement comme classe de base.

Pour spécifier qu'une classe ne peut pas être utilisée comme classe de base :

NotInheritable Class SampleClass
End Class

Pour spécifier qu'une classe peut être utilisée uniquement comme classe de base et ne peut pas être instanciée :

MustInherit Class BaseClass
End Class

Pour plus d'informations, consultez les pages suivantes :

• Inherits Statement
• NotInheritable
• MustInherit

Remplacement de membres

Par défaut, une classe dérivée hérite de tous les membres de sa classe de base. Si vous souhaitez modifier le comportement du membre hérité, vous devez le substituer. Autrement dit, vous pouvez définir une nouvelle implémentation de la méthode, de la propriété ou de l'événement dans la classe dérivée.

Les modificateurs suivants sont utilisés pour contrôler la façon dont les propriétés et les méthodes sont substituées :

Interfaces

Tout comme les classes, les interfaces définissent un ensemble de propriétés, méthodes et événements. Cependant, contrairement aux classes, les interfaces n'assurent pas l'implémentation. Elles sont implémentées par les classes et définies en tant qu'entités distinctes des classes. Une interface représente un contrat, dans le sens où une classe qui implémente une interface doit implémenter tous les aspects de cette interface exactement telle qu'elle a été définie.

Pour définir une interface :

Public Interface ISampleInterface
    Sub DoSomething()
End Interface

Pour implémenter une interface dans une classe :

Class SampleClass
    Implements ISampleInterface
    Sub DoSomething
        ' Method implementation.
    End Sub
End Class

Pour plus d'informations, consultez les pages suivantes :

• Interfaces
• Interface (instruction)
• Implements, instruction

Génériques

Les classes, les structs, les interfaces et les méthodes dans .NET peuvent inclure des paramètres de type, qui définissent les types d’objets qu’ils peuvent stocker ou utiliser. L’exemple le plus commun de génériques est une collection dans laquelle vous pouvez spécifier le type d’objets à stocker dans une collection.

Pour définir une classe générique :

Class SampleGeneric(Of T)
    Public Field As T
End Class

Pour créer une instance de classe générique :

Dim sampleObject As New SampleGeneric(Of String)
sampleObject.Field = "Sample string"

Pour plus d'informations, consultez les pages suivantes :

• Génériques
• Generic Types in Visual Basic

Délégués

Un délégué est un type qui définit une signature de méthode et peut fournir une référence à toute méthode avec une signature compatible. Vous pouvez appeler la méthode par le biais du délégué. Les délégués sont utilisés pour passer des méthodes comme arguments à d'autres méthodes.

Pour créer un délégué :

Delegate Sub SampleDelegate(ByVal str As String)

Pour créer une référence à une méthode qui correspond à la signature spécifiée par le délégué :

Class SampleClass
    ' Method that matches the SampleDelegate signature.
    Sub SampleSub(ByVal str As String)
        ' Add code here.
    End Sub
    ' Method that instantiates the delegate.
    Sub SampleDelegateSub()
        Dim sd As SampleDelegate = AddressOf SampleSub
        sd("Sample string")
    End Sub
End Class

Pour plus d'informations, consultez les pages suivantes :

• Délégués
• Delegate, instruction
• AddressOf (opérateur)

Voir aussi

• Guide de programmation Visual Basic