{"id":55000734,"date":"2010-08-01T00:00:00","date_gmt":"2020-05-22T22:06:47","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=734"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Schnittstellenvererbung","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/","title":{"rendered":"Schnittstellenvererbung"},"content":{"rendered":"

\"\"<\/p>\n

Access-Entwickler sind nicht gerade verwöhnt, wenn es um objektorientierte Techniken unter VBA geht. Es gibt zwar die Möglichkeit, Klassen zu programmieren und Objekte auf Basis dieser Klassen zu erzeugen, aber Features wie Vererbung fallen weitgehend flach. Weitgehend Nun, zumindest die sogenannte Schnittstellenvererbung ist unter VBA möglich. Damit können Sie immerhin mehrere Ausprägungen einer Klasse nach den Vorgaben einer Schnittstelle implementieren und diese je nach Bedarf austauschen.<\/b><\/p>\n

Bevor wir uns den technischen Feinheiten widmen, schauen wir uns erstmal den Sinn und Zweck der Schnittstellenvererbung an. Es gibt Anforderungen, die sehr ähnliche Vorgänge mit verschiedenen Techniken umsetzen. Ein Beispiel dafür ist das Versenden von E-Mails: Sie können dazu Outlook fernsteuern oder alternativ eine der vielen Klassen zum direkten Versenden von E-Mails via Winsock und SMTP einsetzen. Für Ihre Anwendung ist das Ziel immer gleich: Die E-Mail soll beim Empfänger ankommen und dafür stellen wir ein Paket aus Informationen wie Empfänger, Absender, Betreff und Inhalt der E-Mail zusammen. Der Rest interessiert uns nicht – dies sollen entsprechende Prozeduren erledigen.<\/p>\n

Ein ähnliches Beispiel ist die Ausgabe von Daten. Diese sollen einmal in einem Bericht landen, ein anderes Mal in einem Word-Dokument, vielleicht aber auch einfach in einer Textdatei, in einem HTML- oder XML-Dokument oder als schlichte Ausgabe im Direktfenster des VBA-Editors.<\/p>\n

Auch hier haben wir wenig Lust, uns darum zu kümmern, wie der Inhalt im entsprechenden Ausgabeformat landet – wir möchten höchstens festlegen, welches Ausgabeformat verwendet wird und gegebenenfalls die dorthin geschickten Daten filtern oder sortieren.<\/p>\n

Dies alles ist mit herkömmlichen Prozeduren möglich. Im Falle der E-Mails würden Sie die Daten wie Absender, Empfänger, Betreff und Text etwa per Formular abfragen und dann die Prozedur zum Versenden der E-Mail aufrufen.<\/p>\n

Diese entscheidet dann auf Basis vorher festgelegter Kriterien, ob die E-Mail mit Outlook oder direkt per SMTP verschickt wird, und steuert den entsprechenden Zweig einer If…Then<\/b>– oder Select Case<\/b>-Bedingung an. In den verschiedenen Zweigen steckt dann versandspezifischer Code oder schlicht ein Aufruf einer Funktion, welche den Versand auf die angegebene Weise durchführt.<\/p>\n

Sie würden dann beispielsweise zwei Funktionen definieren, deren Prozedurköpfe etwa so aussehen:<\/p>\n

Public Function MailToOutlook(strSender As String, strRecipient As String, strSubject As String, strBody As String)\r\n    Public Function MailToSMTP(strSender As String, strRecipient As String, strSubject As String, strBody As String)<\/pre>\n
Die aufrufende Prozedur enthielte dann beispielsweise den folgenden Code:<\/p>\n
Select Case strVersandart\r\n    Case "Outlook"\r\n        Call MailToOutlook (...)\r\n    Case "SMTP"\r\n        Call MailToSMTP (...)\r\nEnd Select<\/pre>\n
Sie haben hier alle Freiheiten: Die Funktionen MailToOutlook <\/b>oder MailToSMTP <\/b>könnten beispielsweise auch zusätzliche Parameter verwenden, oder Sie erweitern das Select Case<\/b>-Statement um eine dritte Methode zum Versenden von E-Mails.<\/p>\n
Klasse Funktion<\/b><\/p>\n
Die Funktionen zum Versenden von E-Mails könnten auch in zwei Klassen ausgelagert werden. Die Klasse zum Versenden von E-Mails via SMTP könnte beispielsweise wie in Listing 1 aussehen. Die Klasse für den Versand mit Outlook sieht genauso aus, nur dass die Methode zum Versenden der E-Mail den Namen SendSMTPMail <\/b>besitzt.<\/p>\n
Listing 1: Klasse zum Versenden von E-Mails via SMTP<\/p>\n
Private m_Sender As String\r\nPrivate m_Recipient As String\r\nPrivate m_Subject As String\r\nPrivate m_Body As String\r\nPublic Property Let Sender(strSender As String)\r\n    m_Sender = strSender\r\nEnd Property\r\nPublic Property Let Recipient(strRecipient As String)\r\n    m_Recipient = strRecipient\r\nEnd Property\r\nPublic Property Let Subject(strSubject As String)\r\n    m_Subject = strSubject\r\nEnd Property\r\nPublic Property Let Body(strBody As String)\r\n    m_Body = strBody\r\nEnd Property\r\nPublic Function SendSMTPMail() As Boolean\r\n    ''... Code zum Senden der Mail per SMTP\r\n    SendSMTPMail = True\r\nEnd Function<\/pre>\n
Eine Prozedur, welche eine dieser beiden Klassen aufruft, sieht etwa wie in Listing 2<\/a> aus. Sie bekommt per Parameter den Versender, den Empfänger, den Betreff und den Inhalt sowie die Versandart übermittelt. Mit diesen Informationen entscheidet die Select Case<\/b>-Bedingung, welcher der beiden Zweige angesteuert werden soll.<\/p>\n
Listing 2: Instanzierung der Klassen zum Versenden von E-Mails und Versenden der E-Mail<\/p>\n
Public Sub MailVersenden(strAbsender As String, strEmpfaenger As String, strBetreff As String, strInhalt As String, strVersandart As String)\r\n    Dim objSendSMTPMail As clsSendSMTPMail\r\n    Dim objSendOutlookMail As clsSendOutlookMail\r\n    Select Case strVersandart\r\n        Case "SMTP"\r\n            Set objSendSMTPMail = New clsSendSMTPMail\r\n            With objSendSMTPMail\r\n                .Sender = strAbsender\r\n                .Recipient = strEmpfaenger\r\n                .Subject = strBetreff\r\n                .Body = strInhalt\r\n                If .SendSMTPMail = True Then\r\n                    MsgBox "Versand via SMTP erfolgreich!"\r\n                End If\r\n            End With\r\n        Case "Outlook"\r\n            Set objSendOutlookMail = New clsSendOutlookMail\r\n            With objSendOutlookMail\r\n                .Sender = strAbsender\r\n                .Recipient = strEmpfaenger\r\n                .Subject = strBetreff\r\n                .Body = strInhalt\r\n                If .SendOutlookMail = True Then\r\n                    MsgBox "Versand via Outlook erfolgreich!"\r\n                End If\r\n            End With\r\n    End Select\r\nEnd Sub<\/pre>\n
Dadurch wird eine der beiden Klassen clsSendSMTPMail <\/b>und clsSendOutlookMail <\/b>instanziert. Danach füllt die Prozedur die Eigenschaften des auf diese Weise erzeugten Objekts und initiiert den Mailversand durch den Aufruf der Methode SendSMTPMail <\/b>beziehungsweise SendOutlookMail<\/b>.<\/p>\n
Enge Kopplung<\/b><\/p>\n
Die aufrufende Klasse ist dann allerdings sehr eng an die aufgerufenen Klassen gekoppelt. Wenn Sie die aufgerufenen Klassen so gestalten können, dass diese alle eine einheitliche Schnittstelle bieten – das heißt, dass jede Klasse die gleichen Methoden und Eigenschaften enthält -, können Sie eine abstrakte Schnittstelle für diese Klassen erstellen. Diese Schnittstelle fungiert dabei als eine Art „Vertrag“ – sie legt genau fest, wie die Implementierung der Klasse aussehen muss.<\/p>\n
<\/p>\n
Klasse als Schnittstelle<\/b><\/p>\n
Diese Schnittstelle ist eine eigene Klasse, die alle enthaltenen Methoden und Eigenschaften festlegt, aber keine Implementierungsdetails enthält. <\/p>\n
Sie sagt also beispielsweise: Die Klasse, die meine Schnittstelle implementiert, muss vier öffentliche Property Let<\/b>-Parameter namens strSender<\/b>, strRecipient<\/b>, strSubject <\/b>und strBody <\/b>mit dem Datentyp String <\/b>und eine öffentliche Sub<\/b>-Methode namens Send <\/b>aufweisen – nicht mehr und nicht weniger.<\/p>\n
Die Implementierung dieser Methoden und Eigenschaften folgt erst in den eigentlichen Klassen.<\/p>\n
Die Implementierung enthält die eigentliche Funktionalität. Um sicherzustellen, dass die in der Schnittstelle vorgegebene Definition eingehalten wird, enthält diese Klasse die Anweisung Implements ISendMail<\/b>. Die implementierten Methoden und Eigenschaften weisen eine spezielle Notation auf: Diese besteht aus dem Namen der zu implementierenden Schnittstelle, einem Unterstrich (_) und dem in der Schnittstellendefinition festgelegten Methoden- oder Eigenschaftsnamen.<\/p>\n
Von der Klasse zur Schnittstelle<\/b><\/p>\n
Wenn Sie bereits eine Klasse verwenden, welche die Eigenschaften und Methoden der geplanten Schnittstelle enthält, können Sie daraus ganz einfach die Schnittstelle erstellen: Werfen Sie einfach jede Codezeile mit Ausnahme von Option Explicit <\/b>und gegebenenfalls Option Database <\/b>sowie der eigentlichen Gerüste der öffentlichen Methoden und Eigenschaften raus. Wenn Sie die Klasse aus Listing 1<\/a> derart bearbeiten, bleibt der in Listing 3<\/a> dargestellte Rest. Diese Klasse speichern Sie unter dem Namen ISendMail<\/b>. Das I <\/b>steht für Interface<\/b>, also Schnittstelle<\/b>, und deutet darauf hin, dass diese Klasse nur die Schnittstellenbeschreibung und keinerlei Implementierung irgendwelcher Funktionen enthält.<\/p>\n
Listing 3: Definition der Schnittstelle für die Klassen zum Versenden von E-Mails<\/p>\n
Option Compare Database\r\nOption Explicit\r\nPublic Property Let Sender(strSender As String)\r\nEnd Property\r\nPublic Property Let Recipient(strRecipient As String)\r\nEnd Property\r\nPublic Property Let Subject(strSubject As String)\r\nEnd Property\r\nPublic Property Let Body(strBody As String)\r\nEnd Property\r\nPublic Function SendMail() As Boolean\r\nEnd Function<\/pre>\n
Der einzige Unterschied in der Deklaration der Prozedurköpfe ist der, dass wir die Function-Prozedur SendSMTPMail <\/b>in SendMail <\/b>umbenannt haben. Der Grund ist klar: Die Schnittstelle soll später stellvertretend für beide vorhandenen oder sogar für noch weitere Klassen verwendet werden und deshalb neutrale, von der verwendeten Methode unabhängige Bezeichnungen aufweisen.<\/p>\n
Anpassen der Implementierungen<\/b><\/p>\n
Damit wir die beiden Klassen clsSendOutlookMail <\/b>und clsSendSMTPMail <\/b>später als Implementierung nutzen können, müssen wir diesen mitteilen, dass sie die Schnittstelle ISendMail <\/b>implementieren.<\/p>\n
Wenn Sie dies mit einer vorhandenen Klasse durchführen, brauchen Sie dieser zunächst nur die folgende Zeile im Kopf des Moduls hinzuzufügen:<\/p>\n
Implements ISendMail<\/pre>\n
Um zu prüfen, ob die Klasse alle in der Schnittstelle vorgegebenen Elemente implementiert, brauchen Sie nur das Projekt zu kompilieren (VBA-Editor, Menüeintrag Debuggen|Kompilieren von <Projektname><\/b>). Das Ergebnis des ersten Anlaufs sehen Sie in Bild 1. Die Implementierung der Property<\/b>-Prozedur Sender <\/b>ist nicht in Ordnung. Die Lösung ist einfach: Alle Elemente der Implementierungen einer Schnittstelle müssen mit dem Namen der Schnittstellenklasse und einem Unterstrich beginnen, also beispielsweise ISendMail_Sender <\/b>statt einfach nur Sender<\/b>. <\/p>\n
\"pic001.png\"<\/p>\n
Bild 1: Wenn nicht alle in der Schnittstelle definierten Elemente implementiert sind, meckert Access beim Kompilieren.<\/span><\/b><\/p>\n
Die vollständige Umwandlung der Klasse clsSendSMTPMail <\/b>aus Listing 1<\/a> in eine Implementierung der Klasse ISendMail <\/b>sieht wie in Listing 4<\/a> aus.<\/p>\n
Wenn Sie clsSendSMTPMail<\/b> und clsSendOutlookMail <\/b>wie in diesem Listing in eine Implementation von ISendMail <\/b>umgewandelt haben, können Sie die Prozedur, die diese Klassen verwendet, wie in Listing 5<\/a> anpassen.<\/p>\n
Listing 4: Die Implementierung der Schnittstelle ISendMail für das Versenden von E-Mails mit SMTP<\/p>\n
Implements ISendMail\r\n''...Deklarationen\r\nPrivate Property Let ISendMail_Sender(strSender As String)\r\n    m_Sender = strSender\r\nEnd Property\r\nPrivate Property Let ISendMail_Recipient(strRecipient As String)\r\n    m_Recipient = strRecipient\r\nEnd Property\r\nPrivate Property Let ISendMail_Subject(strSubject As String)\r\n    m_Subject = strSubject\r\nEnd Property\r\nPrivate Property Let ISendMail_Body(strBody As String)\r\n    m_Body = strBody\r\nEnd Property\r\nPrivate Function ISendMail_SendMail() As Boolean\r\n    ''... Code zum Senden der Mail per SMTP\r\n    ISendMail_SendMail = True\r\nEnd Function<\/pre>\n
Lose Kopplung<\/b><\/p>\n
    <\/p>\n
Die lose Kopplung zwischen der aufrufenden Klasse und der Implementierung der Schnittstelle erreichen Sie dadurch, dass nicht die konkrete aufzurufende Klasse deklariert wird, sondern nur die Schnittstelle (Dim objSendMail As ISendMail<\/b>). Erst die Instanzierung legt konkret die zu verwendende Klasse fest (Set objSendMail = clsSendSMTPMail <\/b>beziehungsweise Set objSendMail = clsSendOutlookMail<\/b>).<\/p>\n
Sie können nun beliebige weitere Implementierungen der Schnittstelle erzeugen und diese nach Bedarf einsetzen. Der große Vorteil dabei ist: Durch die Verwendung der Schnittstelle legen Sie exakt fest, was deren Implementierungen für Methoden und Eigenschaften anbieten – Sie können also in aufrufenden Routinen gegen diese Schnittstelle programmieren, ohne sich um die enthaltenen Details zu kümmern.<\/p>\n
Wenn Sie die Implementierungen dieser Schnittstelle wie in Listing 5<\/a> verwenden, brauchen Sie zum Hinzufügen einer weiteren Implementierung nur zwei Zeilen hinzuzufügen, und zum Entfernen einer Implementierung brauchen Sie lediglich zwei Zeilen zu entfernen.<\/p>\n
Listing 5: Wahlweiser Aufruf zweier Implementierungen der gleichen Schnittstelle<\/p>\n
Public Sub MailVersenden(strAbsender As String, strEmpfaenger As String, strBetreff As String, strInhalt As String, strVersandart As String)\r\n    Dim objSendMail As ISendMail\r\n    Select Case strVersandart\r\n        Case "SMTP"\r\n            Set objSendMail = New clsSendSMTPMail\r\n        Case "Outlook"\r\n            Set objSendMail = New clsSendOutlookMail\r\n    End Select\r\n    With objSendMail\r\n        .Sender = strAbsender\r\n        .Recipient = strEmpfaenger\r\n        .Subject = strBetreff\r\n        .Body = strInhalt\r\n        If .SendMail = True Then\r\n            MsgBox "Versand erfolgreich!"\r\n        End If\r\n    End With\r\nEnd Sub<\/pre>\n
Syntax von Schnittstellen im Überblick<\/b><\/p>\n
Schnittstellen erhalten einen Klassennamen, der mit dem großgeschriebenen Buchstaben I <\/b>beginnt.<\/p>\n
Schnittstellen enthalten die Deklaration von Sub<\/b>– und Function<\/b>– sowie von Property Let<\/b>\/Get<\/b>\/Set<\/b>-Prozeduren, wobei alle Elemente öffentlich deklariert sind.<\/p>\n
Klassen, die eine oder mehrere Schnittstellen implementieren, erhalten einen beliebigen Namen. Sie müssen allerdings im Kopf die Implements<\/b>-Anweisung enthalten, um festzulegen, welche Schnittstelle implementiert werden soll. Als Argument dieser Anweisung wird der Name der Schnittstellenklasse angegeben:<\/p>\n
Implements <Name der Schnittstelle><\/pre>\n
Zu implementierende Methoden und Eigen-schaften werden privat deklariert. Ihre Namen bestehen aus dem Namen der Schnittstelle, dem Unterstrich und dem Namen der Methode oder der Eigenschaft:<\/p>\n
Private Sub <Schnittstellen>_<Routine>(<Parameter>) As <Typ>\r\nPrivate Function <Schnittstellen>_<Routine>(<Parameter>) As <Typ>\r\nPrivate Property Get <Schnittstellen>_<Routine>() As <Typ>\r\nPrivate Property Let|Set <Schnittstellen>_<Routine>(<Parameter>)<\/pre>\n
Die Deklaration erfolgt über die Schnittstellenklasse:<\/p>\n
Dim objSendMail As ISendMail<\/pre>\n
Die Instanzierung hingegen erfolgt über die konkrete Implementierung, in diesem Fall so:<\/p>\n
Set objSendMail = clsSendOutlookMail<\/pre>\n
oder<\/p>\n
Set objSendMail = clsSendSMTPMail<\/pre>\n
Beim Implementieren der Schnittstelle in einer konkreten Klasse unterstützt der VBA-Editor Sie übrigens. Sie können nämlich nach Auswahl des Namens der Schnittstellenklasse im linken Kombinationsfeld des Codefensters bequem alle Elemente über das rechte Kombinationsfeld hinzufügen (s. Bild 2). Das ist nicht viel, aber besser, als die Deklarationen der Elemente von Hand einzutragen. Moderne Entwicklungsumgebungen wie Visual Studio 2010 fügen nach Eingabe der Implements-Anweisung übrigens alle Element automatisch hinzu – immerhin ist von vornherein klar, dass alle Elemente benötigt werden, um spätere Kompilierfehler zu vermeiden.<\/p>\n
\"pic002.png\"<\/p>\n
Bild 2: Die Kombinationsfelder des Codefensters helfen bei der Implementierung der Elemente einer Schnittstelle.<\/span><\/b><\/p>\n
Zusammenfassung und Ausblick<\/b><\/p>\n
Wenn Sie eine Anforderung haben, deren Abarbeitung auf verschiedene Arten durchgeführt werden kann, die aber dennoch die gleichen Parameter erwartet, ist dies ein toller Ansatz: Sie kennen so erstens genau die Anforderungen an die Implementierung, weil deren Schnittstelle genau definiert ist. Wenn Sie eine neue Implementierung hinzufügen möchten, brauchen Sie nur die neue Klasse zu erstellen und zwei Zeilen zum entsprechenden Select Case<\/b>– oder If…Then<\/b>-Konstrukt hinzuzufügen, welches die Interface<\/b>-Klasse mit der konkreten Implementierung versieht.<\/p>\n
Das hier vorgestellte Beispiel ist zwar schon ziemlich konkret, allerdings fehlt hier echter Code – schließlich melden die Klassen nur, dass ihre Senden<\/b>-Methode aufgerufen wurde, aber es geschieht sonst nichts weiter.<\/p>\n
Ein konkretes Beispiel finden Sie jedoch im Beitrag Tabellen und Felder dokumentieren <\/b>(www.access-im-unternehmen.de\/738<\/b>). Diese Lösung enthält verschiedene Möglichkeiten, die Informationen über Tabellen, Felder, Indizes und Beziehungen zu exportieren: In das Direktfenster, in ein Word-Dokument, in ein HTML-Dokument et cetera. Schauen Sie sich diesen Beitrag an, wenn Sie das hier vorgestellte Konzept anhand eines echten Beispiels nachvollziehen möchten.<\/p>\n
In einem weiteren Beitrag namens Das Factory-Pattern <\/b>(www.access-im-unternehmen.de\/735<\/b>) führen wir diese Technik noch ein Stückchen weiter: Wir zeigen Ihnen, wie Sie die verschiedenen Implementierungen einsetzen, ohne den Code, der mit der entsprechenden Instanz arbeitet, überhaupt noch anpassen zu müssen.<\/p>\n
Dazu lagern wir dort die Instanzierung in eine weitere Klasse aus – aber lesen Sie doch einfach den kompletten Beitrag zu diesem Thema.<\/p>\n
Hin und wieder hat sich die Verwendung von Schnittstellen als instabil erwiesen. In diesem Fall können Sie die Klassenvariable auch einfach als Object deklarieren.<\/p>\n
Downloads zu diesem Beitrag<\/h3>\n
Enthaltene Beispieldateien:<\/p>\n
Schnittstellen.mdb<\/p>\n
Download<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
Access-Entwickler sind nicht gerade verwöhnt, wenn es um objektorientierte Techniken unter VBA geht. Es gibt zwar die Möglichkeit, Klassen zu programmieren und Objekte auf Basis dieser Klassen zu erzeugen, aber Features wie Vererbung fallen weitgehend flach. Weitgehend Nun, zumindest die sogenannte Schnittstellenvererbung ist unter VBA möglich. Damit können Sie immerhin mehrere Ausprägungen einer Klasse nach den Vorgaben einer Schnittstelle implementieren und diese je nach Bedarf austauschen.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662010,66042010,44000025],"tags":[],"class_list":["post-55000734","post","type-post","status-publish","format-standard","hentry","category-662010","category-66042010","category-VBA_und_Programmiertechniken"],"yoast_head":"\nSchnittstellenvererbung - Access im Unternehmen<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Schnittstellenvererbung\" \/>\n<meta property=\"og:description\" content=\"Access-Entwickler sind nicht gerade verwöhnt, wenn es um objektorientierte Techniken unter VBA geht. Es gibt zwar die Möglichkeit, Klassen zu programmieren und Objekte auf Basis dieser Klassen zu erzeugen, aber Features wie Vererbung fallen weitgehend flach. Weitgehend Nun, zumindest die sogenannte Schnittstellenvererbung ist unter VBA möglich. Damit können Sie immerhin mehrere Ausprägungen einer Klasse nach den Vorgaben einer Schnittstelle implementieren und diese je nach Bedarf austauschen.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/\" \/>\n<meta property=\"og:site_name\" content=\"Access im Unternehmen\" \/>\n<meta property=\"article:published_time\" content=\"2020-05-22T22:06:47+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/vg08.met.vgwort.de\/na\/64416c8cd95d482a88498ebd114c871b\" \/>\n<meta name=\"author\" content=\"Andr\u00e9 Minhorst\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andr\u00e9 Minhorst\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"12\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Schnittstellenvererbung\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Schnittstellenvererbung\\\/\"},\"author\":{\"name\":\"Andr\u00e9 Minhorst\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\"},\"headline\":\"Schnittstellenvererbung\",\"datePublished\":\"2020-05-22T22:06:47+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Schnittstellenvererbung\\\/\"},\"wordCount\":1904,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Schnittstellenvererbung\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg08.met.vgwort.de\\\/na\\\/64416c8cd95d482a88498ebd114c871b\",\"articleSection\":[\"2010\",\"4\\\/2010\",\"VBA und Programmiertechniken\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Schnittstellenvererbung\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Schnittstellenvererbung\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Schnittstellenvererbung\\\/\",\"name\":\"Schnittstellenvererbung - Access im Unternehmen\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Schnittstellenvererbung\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Schnittstellenvererbung\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg08.met.vgwort.de\\\/na\\\/64416c8cd95d482a88498ebd114c871b\",\"datePublished\":\"2020-05-22T22:06:47+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Schnittstellenvererbung\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Schnittstellenvererbung\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Schnittstellenvererbung\\\/#primaryimage\",\"url\":\"http:\\\/\\\/vg08.met.vgwort.de\\\/na\\\/64416c8cd95d482a88498ebd114c871b\",\"contentUrl\":\"http:\\\/\\\/vg08.met.vgwort.de\\\/na\\\/64416c8cd95d482a88498ebd114c871b\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Schnittstellenvererbung\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Schnittstellenvererbung\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"name\":\"Access im Unternehmen\",\"description\":\"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access\",\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/access-im-unternehmen.de\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\",\"name\":\"Andr\u00e9 Minhorst Verlag\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"contentUrl\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"width\":370,\"height\":111,\"caption\":\"Andr\u00e9 Minhorst Verlag\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\",\"name\":\"Andr\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"caption\":\"Andr\u00e9 Minhorst\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Schnittstellenvererbung - Access im Unternehmen","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/","og_locale":"de_DE","og_type":"article","og_title":"Schnittstellenvererbung","og_description":"Access-Entwickler sind nicht gerade verwöhnt, wenn es um objektorientierte Techniken unter VBA geht. Es gibt zwar die Möglichkeit, Klassen zu programmieren und Objekte auf Basis dieser Klassen zu erzeugen, aber Features wie Vererbung fallen weitgehend flach. Weitgehend Nun, zumindest die sogenannte Schnittstellenvererbung ist unter VBA möglich. Damit können Sie immerhin mehrere Ausprägungen einer Klasse nach den Vorgaben einer Schnittstelle implementieren und diese je nach Bedarf austauschen.","og_url":"https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/","og_site_name":"Access im Unternehmen","article_published_time":"2020-05-22T22:06:47+00:00","og_image":[{"url":"http:\/\/vg08.met.vgwort.de\/na\/64416c8cd95d482a88498ebd114c871b","type":"","width":"","height":""}],"author":"Andr\u00e9 Minhorst","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Andr\u00e9 Minhorst","Gesch\u00e4tzte Lesezeit":"12\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/#article","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/"},"author":{"name":"Andr\u00e9 Minhorst","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f"},"headline":"Schnittstellenvererbung","datePublished":"2020-05-22T22:06:47+00:00","mainEntityOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/"},"wordCount":1904,"commentCount":0,"publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/#primaryimage"},"thumbnailUrl":"http:\/\/vg08.met.vgwort.de\/na\/64416c8cd95d482a88498ebd114c871b","articleSection":["2010","4\/2010","VBA und Programmiertechniken"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/","url":"https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/","name":"Schnittstellenvererbung - Access im Unternehmen","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/#website"},"primaryImageOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/#primaryimage"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/#primaryimage"},"thumbnailUrl":"http:\/\/vg08.met.vgwort.de\/na\/64416c8cd95d482a88498ebd114c871b","datePublished":"2020-05-22T22:06:47+00:00","breadcrumb":{"@id":"https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/#primaryimage","url":"http:\/\/vg08.met.vgwort.de\/na\/64416c8cd95d482a88498ebd114c871b","contentUrl":"http:\/\/vg08.met.vgwort.de\/na\/64416c8cd95d482a88498ebd114c871b"},{"@type":"BreadcrumbList","@id":"https:\/\/access-im-unternehmen.de\/Schnittstellenvererbung\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/access-im-unternehmen.de\/"},{"@type":"ListItem","position":2,"name":"Schnittstellenvererbung"}]},{"@type":"WebSite","@id":"https:\/\/access-im-unternehmen.de\/#website","url":"https:\/\/access-im-unternehmen.de\/","name":"Access im Unternehmen","description":"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access","publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/access-im-unternehmen.de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/access-im-unternehmen.de\/#organization","name":"Andr\u00e9 Minhorst Verlag","url":"https:\/\/access-im-unternehmen.de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/","url":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","contentUrl":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","width":370,"height":111,"caption":"Andr\u00e9 Minhorst Verlag"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f","name":"Andr\u00e9 Minhorst","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","caption":"Andr\u00e9 Minhorst"}}]}},"_links":{"self":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000734","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/comments?post=55000734"}],"version-history":[{"count":0,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000734\/revisions"}],"wp:attachment":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/media?parent=55000734"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/categories?post=55000734"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/tags?post=55000734"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}