Éléments fondamentaux de l'héritage (Visual Basic)

  • Article

L’instruction Inherits est utilisée pour déclarer une nouvelle classe, appelée classe dérivée, basée sur une classe existante, appelée classe de base. Les classes dérivées héritent et peuvent étendre les propriétés, méthodes, événements, champs et constantes définis dans la classe de base. La section suivante décrit certaines des règles d’héritage et les modificateurs que vous pouvez utiliser pour modifier la façon dont les classes héritent ou sont héritées :

  • Par défaut, toutes les classes peuvent être héritées, sauf si elles sont marquées avec le mot clé NotInheritable. Les classes peuvent hériter d'autres classes de votre projet ou de classes d'autres assemblages référencés par votre projet.

  • Contrairement aux langages qui autorisent l’héritage multiple, Visual Basic n’autorise qu’un seul héritage dans les classes ; autrement dit, les classes dérivées ne peuvent avoir qu’une seule classe de base. Bien que l’héritage multiple ne soit pas autorisé dans les classes, les classes peuvent implémenter plusieurs interfaces, qui peuvent effectivement atteindre les mêmes fins.

  • Pour empêcher l’exposition d’éléments restreints dans une classe de base, le type d’accès d’une classe dérivée doit être égal ou plus restrictif que sa classe de base. Par exemple, une classe Public ne peut pas hériter d’une classe Friend ou d’une classe Private, et une classe Friend ne peut pas hériter d’une classe Private.

Modificateurs d'héritage

Visual Basic introduit les instructions et les modificateurs de niveau de classe suivants pour prendre en charge l'héritage :

  • Inherits instruction : spécifie la classe de base.

  • NotInheritable modificateur : empêche les programmeurs d’utiliser la classe comme classe de base.

  • MustInherit modificateur : spécifie que la classe est destinée à être utilisée comme classe de base uniquement. Les instances de classes MustInherit ne peuvent pas être créées directement ; elles peuvent uniquement être créées en tant qu’instances de classe de base d’une classe dérivée. (D’autres langages de programmation, tels que C++ et C#, utilisent le terme classe abstraite pour décrire une telle classe.)

Substitution de propriétés et de méthodes dans les classes dérivées

Par défaut, une classe dérivée hérite des propriétés et des méthodes de sa classe de base. Si une propriété ou une méthode héritée doit se comporter différemment dans la classe dérivée, elle peut être remplacée. 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 :

  • Overridable - Permet de remplacer une propriété ou une méthode d’une classe dans une classe dérivée.

  • Overrides - Remplace une Overridable propriété ou une méthode définie dans la classe de base.

  • NotOverridable - Empêche une propriété ou une méthode d'être surchargée dans une classe qui en hérite. Par défaut, les méthodes Public sont NotOverridable.

  • MustOverride - Nécessite qu’une classe dérivée remplace la propriété ou la méthode . Lorsque le mot-clé MustOverride est utilisé, la définition de la méthode se compose uniquement de l'instruction Sub, Function ou Property. Aucune autre déclaration n'est autorisée et, en particulier, il n'y a pas de déclaration End Sub ou End Function. MustOverride les méthodes doivent être déclarées dans les classes MustInherit.

Supposons que vous souhaitiez définir des classes pour gérer la paie. Vous pouvez définir une classe générique Payroll qui contient une méthode RunPayroll qui calcule la paie pour une semaine type. Vous pouvez ensuite utiliser Payroll comme classe de base pour une classe plus spécialisée BonusPayroll , qui pourrait être utilisée lors de la distribution de primes d’employés.

La classe BonusPayroll peut hériter et remplacer la méthode PayEmployee définie dans la classe de base Payroll .

L’exemple suivant définit une classe de base Payroll, et une classe dérivée, BonusPayroll, qui remplace une méthode héritée, PayEmployee. Une procédure, RunPayroll, crée, puis transmet un objet Payroll et un objet BonusPayroll à une fonction, Pay, qui exécute la méthode PayEmployee des deux objets.

Const BonusRate As Decimal = 1.45D
Const PayRate As Decimal = 14.75D

Class Payroll
    Overridable Function PayEmployee(
        ByVal HoursWorked As Decimal,
        ByVal PayRate As Decimal) As Decimal

        PayEmployee = HoursWorked * PayRate
    End Function
End Class

Class BonusPayroll
    Inherits Payroll
    Overrides Function PayEmployee(
        ByVal HoursWorked As Decimal,
        ByVal PayRate As Decimal) As Decimal

        ' The following code calls the original method in the base 
        ' class, and then modifies the returned value.
        PayEmployee = MyBase.PayEmployee(HoursWorked, PayRate) * BonusRate
    End Function
End Class

Sub RunPayroll()
    Dim PayrollItem As Payroll = New Payroll
    Dim BonusPayrollItem As New BonusPayroll
    Dim HoursWorked As Decimal = 40

    MsgBox("Normal pay is: " &
        PayrollItem.PayEmployee(HoursWorked, PayRate))
    MsgBox("Pay with bonus is: " &
        BonusPayrollItem.PayEmployee(HoursWorked, PayRate))
End Sub

Le mot-clé MyBase

Le mot clé MyBase se comporte comme une variable objet faisant référence à la classe de base de l’instance actuelle d’une classe. MyBase est couramment utilisé pour accéder aux membres de la classe de base qui sont remplacés ou masqués dans une classe dérivée. En particulier, MyBase.New est utilisé pour appeler explicitement un constructeur de classe de base à partir d'un constructeur de classe dérivée.

Par exemple, supposons que vous conceviez une classe dérivée qui remplace une méthode héritée de la classe de base. La méthode substituée peut appeler la méthode dans la classe de base et modifier la valeur de retour comme indiqué dans le fragment de code suivant :

Class DerivedClass
    Inherits BaseClass
    Public Overrides Function CalculateShipping(
        ByVal Dist As Double,
        ByVal Rate As Double) As Double

        ' Call the method in the base class and modify the return value.
        Return MyBase.CalculateShipping(Dist, Rate) * 2
    End Function
End Class

La liste suivante décrit les restrictions relatives à l'utilisation MyBase :

  • MyBase fait référence à la classe de base immédiate et à ses membres hérités. Il ne peut pas être utilisé pour accéder aux membres Private de la classe.

  • MyBase est un mot-clé et non un objet réel. MyBase ne peut pas être assigné à une variable, transmis à des procédures ou utilisé dans une Is comparaison.

  • La méthode qui MyBase qualifie n’a pas besoin d’être définie dans la classe de base immédiate ; elle peut plutôt l’être dans une classe de base héritée indirectement. Pour qu’une référence qualifiée par MyBase se compile correctement, une classe de base doit contenir une méthode correspondant au nom et aux types de paramètres qui apparaissent dans l’appel.

  • Vous ne pouvez pas utiliser MyBase pour appeler MustOverride des méthodes de classe de base.

  • MyBase ne peut pas être utilisé pour se qualifier. Par conséquent, le code suivant n'est pas valide :

    MyBase.MyBase.BtnOK_Click()

  • MyBase ne peut pas être utilisé dans les modules.

  • MyBase ne peut pas être utilisé pour accéder aux membres de la classe de base qui sont marqués comme Friend si la classe de base se trouve dans un assemblage différent.

Pour plus d’informations et un autre exemple, consultez Guide pratique pour accéder à une variable masquée par une classe dérivée.

Le mot-clé MyClass

Le mot clé MyClass se comporte comme une variable objet faisant référence à l’instance actuelle d’une classe telle qu’elle a été implémentée à l’origine. MyClass ressemble Me, mais chaque appel de méthode et de propriété sur MyClass est traité comme si la méthode ou la propriété étaient NotOverridable. Par conséquent, la méthode ou la propriété n’est pas affectée par la substitution dans une classe dérivée.

  • MyClass est un mot-clé et non un objet réel. MyClass ne peut pas être assigné à une variable, transmis à des procédures ou utilisé dans une Is comparaison.

  • MyClass fait référence à la classe conteneur et à ses membres hérités.

  • MyClass peut être utilisé comme qualificateur pour les Shared membres.

  • MyClassne peut pas être utilisé à l’intérieur d’une Shared méthode, mais peut être utilisé à l’intérieur d’une méthode instance pour accéder à un membre partagé d’une classe.

  • MyClass ne peut pas être utilisé dans les modules standard.

  • MyClass peut être utilisé pour qualifier une méthode définie dans une classe de base et qui n’a aucune implémentation de la méthode fournie dans cette classe. Une telle référence a la même signification que MyBase.Méthode.

L’exemple suivant compare Me et MyClass.

Class baseClass
    Public Overridable Sub testMethod()
        MsgBox("Base class string")
    End Sub
    Public Sub useMe()
        ' The following call uses the calling class's method, even if
        ' that method is an override.
        Me.testMethod()
    End Sub
    Public Sub useMyClass()
        ' The following call uses this instance's method and not any
        ' override.
        MyClass.testMethod()
    End Sub
End Class
Class derivedClass : Inherits baseClass
    Public Overrides Sub testMethod()
        MsgBox("Derived class string")
    End Sub
End Class
Class testClasses
    Sub startHere()
        Dim testObj As derivedClass = New derivedClass()
        ' The following call displays "Derived class string".
        testObj.useMe()
        ' The following call displays "Base class string".
        testObj.useMyClass()
    End Sub
End Class

Même si derivedClass remplace , le testMethod mot clé dans MyClass nullifie les effets de la substitution, et le compilateur résout l’appel à la version de la classe de base de useMyClasstestMethod.

Voir aussi