Interfaces (Visual Basic)
Interfaces definiëren de eigenschappen, methoden en gebeurtenissen die klassen kunnen implementeren. Met interfaces kunt u functies definiëren als kleine groepen nauw verwante eigenschappen, methoden en gebeurtenissen; Dit vermindert compatibiliteitsproblemen omdat u verbeterde implementaties voor uw interfaces kunt ontwikkelen zonder bestaande code in gevaar te brengen. U kunt op elk gewenst moment nieuwe functies toevoegen door extra interfaces en implementaties te ontwikkelen.
Er zijn verschillende andere redenen waarom u mogelijk interfaces wilt gebruiken in plaats van klassenovername:
Interfaces zijn beter geschikt voor situaties waarin uw toepassingen veel mogelijk niet-gerelateerde objecttypen vereisen om bepaalde functionaliteit te bieden.
Interfaces zijn flexibeler dan basisklassen, omdat u één implementatie kunt definiëren die meerdere interfaces kan implementeren.
Interfaces zijn beter in situaties waarin u de implementatie niet hoeft over te nemen van een basisklasse.
Interfaces zijn handig wanneer u de overname van klassen niet kunt gebruiken. Structuren kunnen bijvoorbeeld niet worden overgenomen van klassen, maar ze kunnen interfaces implementeren.
Interfaces declareren
Interfacedefinities worden tussen de Interface
en End Interface
instructies ingesloten. Na de Interface
instructie kunt u een optionele Inherits
instructie toevoegen waarin een of meer overgenomen interfaces worden vermeld. De Inherits
instructies moeten voorafgaan aan alle andere instructies in de declaratie, met uitzondering van opmerkingen. De resterende instructies in de interfacedefinitie moeten Event
zijn: , Sub
, Function
, Property
, Interface
, , , Class
en Structure
Enum
instructies. Interfaces kunnen geen implementatiecode of instructies bevatten die zijn gekoppeld aan implementatiecode, zoals End Sub
of End Property
.
In een naamruimte zijn Friend
interface-instructies standaard, maar ze kunnen ook expliciet worden gedeclareerd als Public
of Friend
. Interfaces die zijn gedefinieerd in klassen, modules, interfaces en structuren, zijn Public
standaard, maar ze kunnen ook expliciet worden gedeclareerd als Public
, Friend
of Private
Protected
.
Notitie
Het Shadows
trefwoord kan worden toegepast op alle interfaceleden. Het Overloads
trefwoord kan worden toegepast op Sub
, Function
en Property
instructies die zijn gedeclareerd in een interfacedefinitie. Daarnaast Property
kunnen instructies de Default
, ReadOnly
of WriteOnly
modifiers hebben. Geen van de andere modifiers( (Public
, Private
, Friend
, Protected
, Shared
, , Overrides
of Overridable
MustOverride
) zijn toegestaan. Zie Declaratiecontexten en standaardtoegangsniveaus voor meer informatie.
Met de volgende code wordt bijvoorbeeld een interface met één functie, één eigenschap en één gebeurtenis gedefinieerd.
Interface IAsset
Event ComittedChange(ByVal Success As Boolean)
Property Division() As String
Function GetID() As Integer
End Interface
Interfaces implementeren
Het Visual Basic gereserveerde woord Implements
wordt op twee manieren gebruikt. De Implements
instructie geeft aan dat een klasse of structuur een interface implementeert. Het Implements
trefwoord geeft aan dat een klasselid of structuurlid een specifiek interfacelid implementeert.
Implementeert instructie
Als een klasse of structuur een of meer interfaces implementeert, moet deze de Implements
instructie direct na de Class
of Structure
instructie bevatten. Voor de Implements
instructie moet een door komma's gescheiden lijst met interfaces worden geïmplementeerd door een klasse. De klasse of structuur moet alle interfaceleden implementeren met behulp van het Implements
trefwoord.
Implementeert trefwoord
Voor het Implements
trefwoord moet een door komma's gescheiden lijst met interfaceleden worden geïmplementeerd. Over het algemeen wordt slechts één interfacelid opgegeven, maar u kunt meerdere leden opgeven. De specificatie van een interfacelid bestaat uit de interfacenaam, die moet worden opgegeven in een implementatie-instructie binnen de klasse; een punt; en de naam van de lidfunctie, eigenschap of gebeurtenis die moet worden geïmplementeerd. De naam van een lid dat een interfacelid implementeert, kan elke juridische id gebruiken en is niet beperkt tot de InterfaceName_MethodName
conventie die wordt gebruikt in eerdere versies van Visual Basic.
De volgende code laat bijvoorbeeld zien hoe u een subroutine met de naam Sub1
declareert waarmee een methode van een interface wordt geïmplementeerd:
Class Class1
Implements interfaceclass.interface2
Sub Sub1(ByVal i As Integer) Implements interfaceclass.interface2.Sub1
End Sub
End Class
De parametertypen en retourtypen van het implementatielid moeten overeenkomen met de interface-eigenschap of liddeclaratie in de interface. De meest voorkomende manier om een element van een interface te implementeren, is met een lid dat dezelfde naam heeft als de interface, zoals wordt weergegeven in het vorige voorbeeld.
Als u de implementatie van een interfacemethode wilt declareren, kunt u alle kenmerken gebruiken die juridisch zijn voor instantiemethodedeclaraties, waaronder Overloads
, , Overridable
Overrides
, Protected
Private
MustOverride
Friend
Protected Friend
Public
, en . Default
Static
Het Shared
kenmerk is niet legaal omdat het een klasse definieert in plaats van een instantiemethode.
Met behulp van Implements
kunt u ook één methode schrijven waarmee meerdere methoden worden geïmplementeerd die zijn gedefinieerd in een interface, zoals in het volgende voorbeeld:
Class Class2
Implements I1, I2
Protected Sub M1() Implements I1.M1, I1.M2, I2.M3, I2.M4
End Sub
End Class
U kunt een privélid gebruiken om een interfacelid te implementeren. Wanneer een privélid een lid van een interface implementeert, wordt dat lid beschikbaar via de interface, ook al is het niet rechtstreeks beschikbaar op objectvariabelen voor de klasse.
Voorbeelden van interface-implementatie
Klassen die een interface implementeren, moeten alle eigenschappen, methoden en gebeurtenissen ervan implementeren.
In het volgende voorbeeld worden twee interfaces gedefinieerd. De tweede interface, Interface2
neemt een extra eigenschap en methode over Interface1
en definieert deze.
Interface Interface1
Sub sub1(ByVal i As Integer)
End Interface
' Demonstrates interface inheritance.
Interface Interface2
Inherits Interface1
Sub M1(ByVal y As Integer)
ReadOnly Property Num() As Integer
End Interface
In het volgende voorbeeld wordt de interface geïmplementeerd Interface1
die in het vorige voorbeeld is gedefinieerd:
Public Class ImplementationClass1
Implements Interface1
Sub Sub1(ByVal i As Integer) Implements Interface1.sub1
' Insert code here to implement this method.
End Sub
End Class
In het laatste voorbeeld wordt Interface2
geïmplementeerd, inclusief een methode die is overgenomen van Interface1
:
Public Class ImplementationClass2
Implements Interface2
Dim INum As Integer = 0
Sub sub1(ByVal i As Integer) Implements Interface2.sub1
' Insert code here that implements this method.
End Sub
Sub M1(ByVal x As Integer) Implements Interface2.M1
' Insert code here to implement this method.
End Sub
ReadOnly Property Num() As Integer Implements Interface2.Num
Get
Num = INum
End Get
End Property
End Class
U kunt een alleen-lezeneigenschap implementeren met een eigenschap readwrite (dat wil zeggen dat u deze niet alleen-lezen hoeft te declareren in de implementatieklasse). Het implementeren van een interface belooft ten minste de leden te implementeren die door de interface worden aangegeven, maar u kunt meer functionaliteit bieden, zoals het mogelijk maken van uw eigenschap te beschrijfbaar zijn.
Verwante onderwerpen
Titel | Beschrijving |
---|---|
Overzicht: Interfaces maken en implementeren | Biedt een gedetailleerde procedure waarmee u uw eigen interface kunt definiëren en implementeren. |
Afwijking in algemene interfaces | Beschrijft covariantie en contravariantie in algemene interfaces en biedt een lijst met variant-algemene interfaces in de .NET Framework. |