Exportieren (0) Drucken
Alle erweitern
Erweitern Minimieren

Vererbung aus einer Basisklasse in Microsoft .NET

Veröffentlicht: 04. Feb 2002 | Aktualisiert : 14. Jun 2004

Von Paul D. Sheriff

In diesem Artikel wird die Vererbung erläutert. Außerdem werden die Vererbung aus einer Basisklasse und die Implementierungs- und Schnittstellenvererbung in Microsoft .NET beschrieben.

Auf dieser Seite

Voraussetzungen
Überblick über Vererbung
Vererbung aus einer Basisklasse
Erstellen des Beispielformulars
Erstellen der Unterklasse
Hinzufügen von weiteren Funktionen
"MyBase"-Schlüsselwort
Abstrakte Klassen
Auswählen des zu verwendenden Vererbungstyps
Neuerungen gegenüber Visual Basic 6.0
Zusammenfassung
Informant Communications Group

Ziele

  • Überblick über Vererbung

  • Vererbung aus einer Basisklasse

  • Schnittstellenvererbung

  • Implementierungsvererbung

Voraussetzungen

Sie sollten folgende Voraussetzungen erfüllen, um dieses Dokument optimal nutzen zu können:

  • Sie besitzen grundlegende Codekenntnisse.

  • Sie verstehen die Funktionsweise von Klassen und/oder haben den Artikel Creating Classes in .NET (in Englisch) gelesen.

  • Sie haben Zugriff auf Microsoft Visual Basic .NET.

Überblick über Vererbung

Eines der Hauptfeatures der OOP-Sprachen (Object Oriented Programming) ist die Vererbung. Vererbung ist die Fähigkeit, alle Funktionen einer vorhandenen Klasse nutzen zu können und diese Funktionen auszuweiten, ohne die ursprüngliche Klasse umschreiben zu müssen. Vor der Veröffentlichung von Microsoft Visual Basic .NET war dies Visual Basic-Programmierern nicht möglich. In Visual Basic .NET können Sie sowohl aus Klassen erben, die im Lieferumfang von Microsoft .NET Framework enthalten sind, als auch aus von Ihnen erstellten Klassen. In diesem Dokument lernen Sie, wie Sie die Vererbung verwenden und wie Sie damit den Zeitaufwand für das Programmieren erheblich verringern können.

Ein einfaches Beispiel

Sie werden feststellen, dass Sie in vielen Klassen, die Sie erstellen, dieselben Eigenschaften und Methoden benötigen wie in einer zuvor erstellten Klasse. Nehmen wir an, Sie haben die Basisklasse Person mit den Eigenschaften LastName (Nachname) und FirstName (Vorname) und einer Print-Methode. Sie werden feststellen, dass Sie für die Klasse Employee (Mitarbeiter) dieselben Eigenschaften und Methoden benötigen. Darüber hinaus benötigen Sie weitere Eigenschaften, z.B. EmployeeID (Mitarbeiternummer) und Salary (Gehalt). Wenn Sie aus der Klasse Person (der Basisklasse) erben, können Sie diese Eigenschaften der neuen Employee-Klasse hinzufügen und haben dennoch weiterhin Zugriff auf alle Eigenschaften der Klasse Person. Vererbung ist die Fähigkeit einer Klasse, sich selbst als im Besitz aller Eigenschaften und Methoden einer bestimmten Klasse zu definieren. Anschließend wird die Definition der Basisklasse erweitert, indem weitere Eigenschaften und Methoden hinzugefügt werden.

Vererbungsterminologie

Wir sollten gleich zu Beginn einige Begriffe klären. Eine neue Klasse, die durch Vererbung erstellt wird, wird als untergeordnete Klasse oder Unterklasse bezeichnet. Die Klasse, aus der die Vererbung erfolgt, wird als Basisklasse oder übergeordnete Klasse bezeichnet. In einigen OOP-Sprachen kann eine Unterklasse aus mehr als einer Basisklasse erben. Das heißt, wenn Sie eine Klasse Person und eine Klasse Car (Auto) haben, kann die Klasse Driver (Fahrer) alle Eigenschaften und Methoden aus diesen beiden Klassen erben. Bei .NET hingegen ist nur Einzelvererbung zulässig, d.h., jede Unterklasse hat nur eine Basisklasse.

.NET unterstützt drei Vererbungstypen: Implementierungsvererbung, Schnittstellenvererbung und visuelle Vererbung. Implementierungsvererbung ist die Fähigkeit, die Eigenschaften und Methoden einer Klasse ohne zusätzliche Codierung zu nutzen. Bei der Schnittstellenvererbung werden nur die Namen der Eigenschaften und Methoden verwendet, die Implementierung hingegen muss von der untergeordneten Klasse bereitgestellt werden. Visuelle Vererbung ist die Fähigkeit eines untergeordneten Formulars bzw. einer Unterklasse, sowohl die visuelle Darstellung der Basisformen (Basisklasse) als auch den implementierten Code zu verwenden.

Eine Klasse in .NET kann aus einer Klasse erben, die bereits von einer anderen Klasse geerbt hat. Darüber hinaus können Sie eine oder sogar mehrere Schnittstellen innerhalb einer Klasse verwenden.

Gründe für die Verwendung von Vererbung

Vererbung ist erstrebenswert, da Sie es vermeiden möchten, immer wieder denselben Code schreiben zu müssen. Wenn Sie zwei separate Klassen haben und jede dieser Klassen eine FirstName- und LastName-Eigenschaft implementieren muss, ist der Code doppelt vorhanden. Wenn Sie die Implementierung einer dieser Eigenschaften ändern möchten, müssen Sie alle Klassen finden, die diese Eigenschaften implementiert haben, um die Änderungen vornehmen zu können. Dies ist nicht nur zeitaufwändig, sondern birgt auch das Risiko der Entstehung von Fehlern in den einzelnen Klassen.

Wenn Sie die Verwendung von Vererbung erwägen, müssen Sie beachten, dass es sich bei der Beziehung zwischen den beiden Klassen um eine Beziehung vom Typ "ist ein(e)" handeln sollte. So ist z.B. ein Mitarbeiter eine Person, und ein Manager ist eine Person, d.h., diese beiden Klassen können aus der Klasse Person erben. Die Klasse Leg hingegen sollte nicht aus der Klasse Person erben, da es sich dabei nicht um eine Person handelt.

Überschreibung

Sobald Sie mit der Vererbung von Funktionen aus einer Basisklasse beginnen, werden Sie feststellen, dass die generische Methode, die Sie in der Basisklasse geschrieben haben, nur einen Teil der Funktionen ausführt, die Sie in der Unterklasse benötigen. Anstatt eine völlig neue Methode mit einem neuen Namen zu erstellen, um die gewünschte Funktionalität auszuführen, können Sie die Methode der Basisklasse in dieser neuen Klasse überschreiben.

Beim Überschreiben können Sie die Methode der Basisklasse entweder gänzlich überschreiben oder einen Code schreiben, der in der Unterklasse eine bestimmte Funktion ausführt und anschließend die Methode der Basisklasse aufruft. Es ist wichtig, dass Sie beim Überschreiben weiterhin denselben Vertrag (Parameter und Rückgabetyp) verwenden wie bei der ursprünglichen Methode. Sie können auch beschließen, zunächst die Methode der Basisklasse aufzurufen, und den zusätzlichen Code erst schreiben, nachdem die Methode der Basisklasse fertig ausgeführt ist.

Vererbung aus einer Basisklasse

Bei der Vererbung können Sie alle Eigenschaften und Methoden aus einer Klasse in einer anderen Klasse verwenden. Anstatt den Code aus einer Klasse in eine andere kopieren zu müssen, verwenden Sie das Inherits-Schlüsselwort, um die Funktionalität aus der Basisklasse zu übernehmen.

Implementierungsvererbung

In diesem Dokument erstellen Sie eine neue Klasse, LineDelim, die alle Funktionen der Line-Klasse erbt, die im Artikel Creating Classes in .NET (in Englisch) erstellt wurde. Sie erweitern die Line-Klasse, indem Sie zwei weitere Eigenschaften und eine Methode hinzufügen. Mit der ersten Eigenschaft, Delimiter, können Sie ein Trennzeichen abrufen und in der Klasse setzen. Mit dieser Eigenschaft werden alle Leerzeichen in der Zeile durch dieses Trennzeichen ersetzt. Die zweite Eigenschaft, OriginalLine, enthält die ursprüngliche Textzeile, vor der Einfügung des neuen Trennzeichens. Die von Ihnen erstellte neue Methode, ReplaceAll(), ersetzt alle Leerzeichen in der Zeile durch das Trennzeichen. Anschließend lernen Sie, die GetWord-Methode zu überschreiben, so dass sie dieses Trennzeichen anstelle von Leerzeichen verwendet, um die Textzeile zu zerlegen und nach dem ersten Wort zu suchen.

Erstellen des Beispielformulars

Das in Abbildung 1 dargestellte Beispielformular wird verwendet, um die von Ihnen erstellte Beispielklasse zu testen.

Bild01

Abbildung 1. Beispielformular für das Testen der Vererbung

  1. Zum Erstellen des Formulars, das in Abbildung 1 dargestellt ist, klicken Sie auf Projekt und Windows Form hinzufügen.

  2. Geben Sie dem Formular den Namen frmLineTest.vb, und klicken Sie auf OK.

  3. Erstellen Sie anschließend die entsprechenden Steuerelemente im Formular, und legen Sie die Eigenschaften fest, wie in Tabelle 1 abgebildet. Tabelle 1: Formular für das Testen der Vererbung

    Steuerelement

    Eigenschaft

    Wert

    Label

    Name

    Label1

     


    Text

    Textzeile

    TextBox

    Name

    txtLine

     


    Text

    Fischers Fritz fischt frische Fische

    TextBox

    Name

    txtDelim

     


    Text

    ,

    GroupBox

    Name

    fraWord

     


    Text

    Erstes Wort abrufen

    CommandButton

    Name

    btnFirst

     


    Text

    Wort abrufen

    TextBox

    Name

    txtFirstWord

     


    Text

     


     


    ReadOnly

    True

    CommandButton

    Name

    btnReplace

     


    Text

    Ersetzen

    TextBox

    Name

    txtReplace

Erstellen der "Line"-Klasse

Anschließend erstellen Sie die Line-Klasse, aus der die Vererbung erfolgen soll.

  1. Klicken Sie im Menü auf Projekt und Klasse hinzufügen.

  2. Geben Sie den unten abgebildeten Code ein.

    Public Class Line 
        Private mstrLine As String 
        Property Line() As String 
            Get 
                Return mstrLine 
            End Get 
            Set(ByVal Value As String) 
                mstrLine = Value 
            End Set 
        End Property 
        ReadOnly Property Length() As Integer 
            Get 
                Return mstrLine.Length 
            End Get 
        End Property 
        Public Function GetWord() As String 
            Dim astrWords() As String 
            astrWords = mstrLine.Split(" ".ToCharArray()) 
            Return astrWords(0) 
        End Function 
    End Class 
    

Erstellen der Unterklasse

Nachdem Sie nun das Formular und die Basisklasse erstellt haben, können Sie mit dem Vererbungsprozess beginnen.

  1. Klicken Sie auf Projekt und Klasse hinzufügen. Geben Sie der Klasse den Namen LineDelim.vb, und klicken Sie auf OK.

  2. Ändern Sie den Code, den Visual Basic .NET beim Hinzufügen der neuen Klasse für Sie erstellt, damit er wie das unten abgebildete Beispiel aussieht.

    Public Class LineDelim 
        Inherits Line 
    End Class
    

Sie haben die Inherits Line-Anweisung hinzugefügt, damit Sie alle Eigenschaften und Methoden der Line-Klasse in dieser neu erstellten Klasse verwenden können.

Ausprobieren

  1. Öffnen Sie das Formular frmLineTest.vb.

  2. Doppelklicken Sie auf die Schaltfläche Wort abrufen.

  3. Fügen Sie den folgenden Code der Klickereignisprozedur für diese Schaltfläche hinzu:

    Protected Sub btnFirst_Click(ByVal sender As Object, _ 
     ByVal e As System.EventArgs) Handles btnFirst.Click 
        Dim oLine As LineDelim = New LineDelim() 
        oLine.Line = txtLine.Text 
        txtFirstWord.Text = oLine.GetWord() 
    End Sub
    
  4. Führen Sie das Projekt aus, und klicken Sie auf dem Formular auf die Schaltfläche Wort abrufen. Daraufhin sollte das Wort "Fischers" in dem schreibgeschützten Textfeld neben dieser Schaltfläche angezeigt werden.

Die Inherits-Anweisung ist äußerst leistungsstark. Mit nur einer Anweisung sind nun alle Eigenschaften und Methoden der Line-Klasse in der LineDelim-Klasse verfügbar. Diese neue Klasse führt zwar noch keine Funktion aus, Sie können jedoch sehen, dass der gesamte aus der Line-Klasse geerbte Code funktioniert.

Hinzufügen von weiteren Funktionen

Nun können Sie die LineDelim-Klasse mit zusätzlichen Eigenschaften und Methoden versehen. Befolgen Sie die unten aufgeführten Schritte, um der LineDelim-Klasse zwei neue Eigenschaften hinzuzufügen.

  1. Fügen Sie die beiden Private-Variablen hinzu, die nach der im letzten Abschnitt hinzugefügten Inherits-Anweisung angezeigt werden.

    Private mstrDelim As String = " " 
    Private mstrOriginal As String
    
  2. Geben Sie den folgenden Code ein, um die entsprechenden Property-Anweisungen für jede dieser Private-Variablen hinzuzufügen. Sie können diesen Code direkt hinter den beiden Zeilen platzieren, die Sie gerade weiter oben eingegeben haben.

    Public Property Delimiter() As String 
        Get 
            Return mstrDelim 
        End Get 
        Set(ByVal Value As String) 
            mstrDelim = Value 
        End Set 
    End Property 
    Public ReadOnly Property OriginalLine() As String 
        Get 
            Return mstrOriginal 
        End Get 
    End Property
    

Nun können Sie die Delimiter-Eigenschaft verwenden, um den Wert sowohl festzulegen als auch aus der Private-Variablen mstrDelim abzurufen.

Vielleicht möchten Sie nicht, dass jemand anders eine Ihrer Eigenschaften ändert. In diesem Fall können Sie die Eigenschaft mit einem Schreibschutz versehen. Wenden Sie sich dazu von der Set-Anweisung ab, und fügen Sie das ReadOnly-Attribut der Property-Anweisung hinzu. Ein Beispiel hierfür finden Sie in der Deklaration der OriginalLine-Eigenschaft, die im obigen Code angezeigt wird.

Anschließend erstellen Sie eine ReplaceAll-Methode, die alle Leerzeichen in der Textzeile durch das Trennzeichen ersetzt, das an die Delimiter-Eigenschaft übergeben wird.

Public Function ReplaceAll() As String 
    mstrOriginal = MyBase.Line 
    Return MyBase.Line.Replace(" ", mstrDelim.ToChar()) 
End Function

Die ReplaceAll-Methode ruft die ursprüngliche Textzeile aus der Line-Methode der Basisklasse ab. Sie haben die MyBase.Line-Syntax verwendet, um eine Eigenschaft aus der Basisklasse abzurufen. Die ReplaceAll-Funktion platziert den Wert der MyBase.Line-Eigenschaft in der Private-Variablen, mstrOriginal, die Sie soeben für diese Klasse erstellt haben. Die Replace-Methode des String-Datentyps ersetzt alle Instanzen eines Zeichens durch das neue mstrDelim-Trennzeichen, das Sie in der Delimiter-Eigenschaft festgelegt haben.

"MyBase"-Schlüsselwort

Das MyBase-Schlüsselwort kann von jeder Unterklasse aus verwendet werden, um einen Aufruf an eine Eigenschaft oder Methode in der Basisklasse zu senden. Sie können damit sogar die Methode der Basisklasse aufrufen, die Sie in der Unterklasse überschrieben haben. Wenn die Basisklasse z.B. eine ReplaceAll-Methode enthält und Sie diese Methode in der Unterklasse überschrieben haben, können Sie aus der ReplaceAll-Methode in der Unterklasse heraus die ReplaceAll-Methode in der Basisklasse aufrufen.

Ausprobieren

  1. Öffnen Sie das Formular frmLineTest.vb.

  2. Doppelklicken Sie auf Ersetzen, um die Klickereignisprozedur aufzurufen.

  3. Schreiben Sie den nachfolgenden Code in das Klickereignis für die btnReplace-Schaltfläche.

    Protected Sub btnReplace_Click( _  
     ByVal sender As Object, _ 
     ByVal e As System.EventArgs) Handles btnReplace.Click 
        Dim oLine As LineDelim = New LineDelim() 
        oLine.Delimiter = txtDelim.Text 
        oLine.Line = txtLine.Text 
        txtReplace.Text = oLine.ReplaceAll() 
    End Sub
    

    Dieser Code setzt die Delimiter-Eigenschaft auf einen Wert, der in das txtDelimiter-Textfeld im Beispielformular eingegeben wird. Anschließend rufen Sie die ReplaceAll-Methode auf, um alle Leerzeichen in der Textzeile durch das neue Trennzeichen zu ersetzen.

  4. Drücken Sie F5, um das Projekt auszuführen.

  5. Klicken Sie auf Ersetzen. Zwischen den einzelnen Wörtern des Satzes im Textfeld neben der Schaltfläche Ersetzen sollten nun Kommata angezeigt werden.

Überschreiben einer Methode

Nachdem Sie nun eine Delimiter-Eigenschaft hinzugefügt haben, möchten Sie die GetWord-Methode in der LineDelim-Klasse so ändern, dass das Trennzeichen anstelle des einzelnen Leerzeichens der Line-Klasse verwendet wird. Da Sie die Basisklasse nicht unbedingt ändern möchten, müssen Sie die Funktionen der GetWord-Methode in der LineDelim-Klasse überschreiben. Bevor Sie eine neue GetWord-Methode in der LineDelim-Klasse erstellen können, müssen Sie der GetWord-Methodendeklaration in der Line-Klasse ein Schlüsselwort hinzufügen.

  1. Öffnen Sie im Projektmappen-Explorer das Codefenster für die Line.vb-Klasse.

  2. Suchen Sie die Deklaration für die GetWord-Methode (die Deklaration ohne Parameter), wie im Folgenden abgebildet:

    Public Overloads Function GetWord() As String
    
  3. Fügen Sie der Funktionsdeklaration das Overridable-Schlüsselwort hinzu, wie im Folgenden abgebildet. (Ohne dieses Schlüsselwort können Sie diese Methode nicht überschreiben.)

    Public Overridable Overloads Function GetWord() As String
    
  4. Öffnen Sie die LineDelim.vb-Klasse, und fügen Sie über den im Folgenden abgebildeten Code eine neue GetWord-Methode hinzu.

    Public Overloads Overrides Function GetWord() As String 
        Dim astrWords() As String 
        astrWords = MyBase.Line.Split(mstrDelim.ToCharArray()) 
        Return astrWords(0) 
    End Function
    

Das Overrides-Schlüsselwort in der Funktionsdeklaration ist erforderlich, wenn Sie die Funktionalität einer Methode aus der Basisklasse heraus ändern möchten. Die GetWord-Methode in der LineDelim-Klasse verwendet nun den Wert der Delimiter-Eigenschaft, um die Wörter in einem Satz zu trennen.

Wenn Sie nur eine der GetWord-Methoden überschreiben, können Sie nur diese eine Version der Methode sehen. Ihr Code kann die anderen Versionen der GetWord-Methode nicht aufrufen. Damit alle Versionen angezeigt werden, müssen Sie jede einzelne Methode überschreiben, ebenso wie bei der LineDelim-Klasse.

Ausprobieren

  1. Führen Sie das Projekt aus, indem Sie F5 drücken.

  2. Fügen Sie Kommata zwischen den einzelnen Wörtern des Satzes ein, und geben Sie in das Textfeld Trennzeichen ein Komma ein.

  3. Klicken Sie auf Wort abrufen. Das erste Wort im Satz sollte nun im Textfeld neben der Schaltfläche Wort abrufen angezeigt werden.

Abstrakte Klassen

In einem Beispiel weiter oben in diesem Dokument haben Sie gelernt, wie Sie ein generisches Person-Objekt erstellen. Doch vielleicht beschließen Sie, dass Sie mit einer Person-Klasse nichts anfangen können, solange Sie nicht bestimmte Verhaltensweisen und/oder Daten hinzufügen. Somit gestalten Sie die Person-Klasse als abstrakte Klasse, die nur die generischen Eigenschaften und Methoden definiert, die von Unterklassen erstellt werden.

Die Person-Klasse ist als abstrakte Klasse definiert, aus der nur geerbt werden kann, nicht als Objekt, das zur Laufzeit erstellt wird. Jede Klasse, die aus dieser Klasse erbt (z.B. die Employee-Klasse) erstellt alle entsprechenden Eigenschaften und Methoden mit spezifischen Funktionen. So erstellt z.B. die Employee-Klasse eine Print-Methode, während die Person-Klasse lediglich definiert, dass eine Print-Methode vorhanden sein muss. Der Print-Methode in der Person-Klasse ist kein Code zugeordnet.

Es gibt mehrere Gründe, die für die Verwendung von abstrakten Klassen sprechen. Sie erzwingen, dass die Entwickler von Unterklassen alle Schnittstellen implementieren, die eine Anwendung benötigt. Sie können einem untergeordneten Element neue Methoden hinzufügen, ohne Ihre Clientanwendungen zu beschädigen - das ist bei Schnittstellen nicht möglich. Sie können in der Basisklasse eine Vielzahl von Standardimplementierungen bereitstellen, um die Arbeitslast einer untergeordneten Klasse zu verringern.

Schnittstellenvererbung

Wenn Sie eine abstrakte Klasse erstellen möchten, verwenden Sie anstelle von Class das Interface-Schlüsselwort. Sie geben der Schnittstelle einen Namen und definieren die Eigenschaften und Methoden, die eine Unterklasse implementieren soll. Der Grund dafür ist, dass die Basisklasse nichts enthält, was sich zu implementieren lohnen würde - sie umfasst nur generische Daten ohne Methoden. Sie erstellen lediglich einen Vertrag, der festlegt, dass jede Unterklasse, die diese Schnittstelle verwendet, bestimmte Regeln befolgen muss.

  1. Nun fügen wir dem soeben von Ihnen erstellten Projekt eine neue Klasse hinzu.

  2. Klicken Sie im Visual Studio-Menü auf Projekt und Klasse hinzufügen.

  3. Fügen Sie dieser Klasse den folgenden Code hinzu:

    Interface Person 
        Property FirstName() As String 
        Property LastName() As String 
        Sub Print() 
        Sub Talk() 
    End Interface
    

    Wie Sie sehen, definieren Sie Eigenschaften und Unterprozeduren wie gewohnt. Der einzige Unterschied besteht darin, dass Sie keinen Code eingeben müssen. Sehen wir uns nun an, wie Sie diese Schnittstelle in einer Klassendefinition verwenden.

  4. Fügen Sie derselben Klassendatei, die Sie im vorherigen Schritt erstellt haben, den nachfolgend abgebildeten Code hinzu.

    Public Class Employee 
        Implements Person 
        Private mstrFirstName As String 
        Private mstrLastName As String 
        Property FirstName() As String _ 
         Implements Person.FirstName 
            Get 
                Return mstrFirstName 
            End Get 
            Set 
                mstrFirstName = Value 
            End Set 
        End Property 
        Property LastName() As String _ 
         Implements Person.LastName 
            Get 
                Return mstrLastName 
            End Get 
            Set 
                mstrLastName = Value 
            End Set 
        End Property 
        Sub Print() Implements Person.Print 
            ' Code einfügen         
        End Sub 
        Sub Talk() Implements Person.Talk 
            ' Code einfügen 
        End Sub 
    End Class
    

Die erste Zeile nach der Definition der Employee-Klasse lautet Implements Person. Dieses Schlüsselwort besagt, dass Sie den Vertrag befolgen, der in der Person-Schnittstelle dargelegt ist. Nun können Sie die einzelnen Eigenschaften und Methoden in diesem Vertrag definieren. Nach jeder Property-Anweisung müssen Sie das Implements-Schlüsselwort einfügen und den Namen der Schnittstelle, einen Punkt (.) und den Namen der von Ihnen implementierten Schnittstelle/Eigenschaft angeben. Visual Basic .NET verfolgt diese Schnittstellen, und Sie können die Anwendung erst kompilieren, wenn jede einzelne Schnittstelle erstellt ist.

Wenn Sie den Code ausführen möchten, müssen Sie zunächst die entsprechenden Unterprozeduren erstellen - diese wurden im obigen Codebeispiel ausgelassen. Nachdem Sie die einzelnen Schnittstellen erstellt haben, können Sie ein neues Employee-Objekt deklarieren und wie jedes andere Objekt verwenden, das Sie regulär erstellen und nutzen.

Auswählen des zu verwendenden Vererbungstyps

Die Entscheidung zwischen Implementierungs- und Schnittstellenvererbung kann sich recht schwierig gestalten. In vielen Fällen bietet es sich an, ein wenig von beidem zu nutzen. So können Sie z.B. eine Methodendefinition hinzufügen, die von einer Unterklasse der Line-Klasse überschrieben werden muss. Sie implementieren diese Methode, indem Sie das MustOverride-Schlüsselwort in einer Prozedurdefinition verwenden.

Public MustOverride Sub Init()

Wenn Sie diese Definition einer Klasse hinzufügen, verhält sie sich ähnlich wie eine Schnittstelle. In der Unterklasse muss die Init-Methode definiert werden, und es muss das Overrides-Schlüsselwort verwendet werden. Hier sehen Sie ein Beispiel für eine mögliche Definition dieser Init-Methode:

Public Overrides Sub Init() 
   mstrDelim = " " 
   mstrLine = "Testzeile" 
End Sub

Beachten Sie auch hier, wie die Verwendung des Overrides-Schlüsselworts den Compiler darüber informiert, dass diese Methode die Init-Methode in der übergeordneten Klasse überschreibt.

Anmerkung

In der Onlinehilfe zu Microsoft .NET Framework finden Sie Entwurfsrichtlinien, die Ihnen bei der Entscheidung über die zu verwendenden Vererbungstypen helfen können.

Stoppen der Vererbung

In einigen Fällen möchten Sie nicht, dass andere Klassen aus Ihrer Klasse abgeleitet werden. Wenn dies der Fall ist, können Sie die Vererbung für eine Klasse über das NotInheritable-Schlüsselwort stoppen.

Public Class NotInheritable Employee 
   ' Klassendefinition 
End Class

Neuerungen gegenüber Visual Basic 6.0

Mit Visual Basic .NET können Sie aus allen Klassen erben, die im Lieferumfang von .NET Framework enthalten sind. Sie können Ihre eigenen Klassen erstellen, die von vorhandenen Klassen erben, und über einfache Codeänderungen Funktionen hinzufügen oder entfernen.

Zusammenfassung

In diesem Dokument haben Sie gelernt, wie Sie aus einer Basisklasse erben. Sie haben der Basisklasse weitere Eigenschaften hinzugefügt und das Overrides-Schlüsselwort verwendet, um Funktionen zu ersetzen, die in der Basisklasse definiert sind. Außerdem haben Sie gelernt, das MyBase-Schlüsselwort für das Aufrufen von Methoden in der Basisklasse zu verwenden. Auf diese Weise haben Sie die Funktionen der Basisklasse ausgeweitet. Vererbung mag zwar nicht für alle Ihre Anwendungen geeignet sein, Sie werden jedoch feststellen, dass Sie damit bei sachgerechter Verwendung über ein leistungsstarkes Tool verfügen.

Informant Communications Group

Informant Communications Group, Inc. ist ein breitgefächertes Medienunternehmen, das auf den Informationstechnologiesektor ausgerichtet ist. ICG wurde 1990 gegründet und ist spezialisiert auf Softwareentwicklungspublikationen, Konferenzen, Katalogveröffentlichungen und Websites. ICG besitzt Niederlassungen in den USA und Großbritannien und hat sich als zuverlässiger Integrator für Marketing- und Medieninhalte erwiesen, der die wachsende Nachfrage von IT-Spezialisten nach qualitativ hochwertigen technischen Informationen abdeckt.

Links zu verwandten Themen

Anzeigen:
© 2015 Microsoft