Dass man mit Access auch objektorientiert entwickeln kann – wenn auch nicht völlig – dürfte hinlänglich bekannt sein. Klassenmodul erstellen, Methoden und Eigenschaften in als Prozeduren und Properties definieren, alles längst bekannt. Weniger bekannt aber ist die Verwendung von Interfaces bzw. Interface-Klassen.

Man stelle sich vor, man hat eine Klasse Auto, eine Klasse Motorrad und eine Klasse Fahrrad. 3 verschiedene Klassen, und doch werden die Methoden und Eigenschaften dieser Klassen in vielen Punkten identisch sein. Die Objekte aller 3 Klassen haben sicherlich die gemeinsamen Methoden „Fahren“, „Bremsen“ und „Lenken“. Außerdem die gemeinsamen Eigenschaften „Geschwindigkeit“, „Richtung“ und „Farbe“, um ein paar Beispiele zu nennen.

Diese Zusammenhänge lassen sich durch ein Interface abbilden, und das geschieht einfacher als man denkt. Ein Interface ist zuerst einmal nichts anderes als ein Klassenmodul, das man speziell benennt. Eingebürgert hat sich, dass man vor den Interface-Namen ein „i“ setzt. Wir erstellen also ein Klassenmodul, und benennen es „iFahrzeug“. Um jetzt die Struktur für Fahrzeuge in diesem Interface abzubilden erstellen wir darin alle Properties und Prozeduren wie oben benannt, aber ohne weiteren Code. Unser Interface sieht jetzt wie folgt aus:

Option Explicit

Property Get Geschwindigkeit() As Long
End Property
Property Let Geschwindigkeit(ByVal lSpeed As Long)
End Property

Property Get Richtung() As String
End Property
Property Let Richtung(ByVal cRichtung As String)
End Property

Property Get Farbe() As Long
End Property
Property Let Farbe(ByVal lColor As Long)
End Property

Sub Fahren()
End Sub

Sub Bremsen()
End Sub

Sub Lenken()
End Sub

Die Prozeduren und Properties dürfen nicht als private deklariert werden, sonst sind diese bei der Verwendung nicht verfügbar.
Interfaces können nur innerhalb Klassenmodulen und Formularmodulen (Formulare sind praktischer Weise ja auch Klassen) verwendet werden, nicht in Standard-Modulen. Die Einbindung in ein Klassenmodul findet mit dem Schlüsselwort „Implements“ statt. Dies erfolgt in der Klasse direkt nach den Optionen-Deklaration, in unserem Fall also: Implements iFahrzeug.

Sobald man das getan hat steht das Interface zur Nutzung bereit. Dies macht sich durch den Eintrag von iFahrzeug in der linken oberen Auswahlliste bemerkbar (Unterhalb der Symbolleiste). Wählt man darin iFahrzeug aus, wird die erste Property bereits in die Klasse eingefügt. Klickt man anschließend auf die rechte obere Auswahlliste, so sind die restlichen Properties und Prozeduren auswählbar, und können einfach in die Klasse eingefügt werden. Spätestens jetzt sollte die Verwendung von Interfaces klar geworden sein.

Mittels einem Interface wird definiert welche Methoden und Eigenschaften eine Klasse mindestens haben muss!. Das Bedeutet alle in dem Interface definierten Prozeduren und Properties müssen auch in die Klasse übernommen werden. Macht man das nicht so erhält man einen Fehler wenn man das Projekt Kompelliert.

Fügt man die restlichen Properties und Methoden ein, sollte die Klasse jetzt wie folgt aussehen:

Option Compare Database
Option Explicit

Implements iFahrzeug

Private Sub iFahrzeug_Fahren()
End Sub

Private Sub iFahrzeug_Bremsen()
End Sub

Private Sub iFahrzeug_Lenken()
End Sub

Private Property Get iFahrzeug_Farbe() As Long
End Property

Private Property Let iFahrzeug_Farbe(ByVal RHS As Long)
End Property

Private Property Let iFahrzeug_Geschwindigkeit(ByVal RHS As Long)
End Property

Private Property Get iFahrzeug_Geschwindigkeit() As Long
End Property

Private Property Let iFahrzeug_Richtung(ByVal RHS As String)
End Property

Private Property Get iFahrzeug_Richtung() As String
End Property

Jetzt kann man relativ einfach jede Klasse (Auto, Motorrad, Fahrrad) nach dieser „Vorschrift“ erstellen, auscoden und nach Bedarf erweitern.

Fassen wir mal zusammen:

• Interfaces sind Daten- und Zugriffsstrukturen, welche den Zugriff und die Steuerung von Objekten regeln
• Vereinfacht gesagt ist ein Interface eine Struktur an Methoden und Eigenschaften.
• Interfaces sind bestimmte Klassenmodule, die nach einem Schema benannt werden.
• Interfaces enthalten nur die Rümpfe der Prozeduren und Properties. Code darin würde ignoriert werden.
• Eingebunden in Klassenmodulen (oder Formular-Code) werden diese mit dem Schlüsselwort „Implements“
• Objektorientiert Entwickeln ist Cool 😉

Und nun viel Spass beim Experimentieren mit OOP und Interfaces.

Bis dahin
© 2014 Andreas Vogt

Comments are closed