Freigeben über

Vererbung

Die Vererbung wird verwendet, um die Beziehung "is-a" oder subtyping in objektorientierter Programmierung zu modellieren.

Angeben von Vererbungsbeziehungen

Sie geben Vererbungsbeziehungen mithilfe des inherit Schlüsselworts in einer Klassendeklaration an. Die grundlegende syntaktische Form wird im folgenden Beispiel gezeigt.

type MyDerived(...) =
    inherit MyBase(...)

Eine Klasse kann höchstens eine direkte Basisklasse aufweisen. Wenn Sie keine Basisklasse mithilfe des inherit Schlüsselworts angeben, erbt die Klasse implizit von System.Object.

Geerbte Elemente

Wenn eine Klasse von einer anderen Klasse erbt, sind die Methoden und Member der Basisklasse für Benutzer der abgeleiteten Klasse verfügbar, als wären sie direkte Member der abgeleiteten Klasse.

Alle Let-Bindungen und Konstruktorparameter sind privat für eine Klasse und können daher nicht von abgeleiteten Klassen aufgerufen werden.

Das Schlüsselwort base ist in abgeleiteten Klassen verfügbar und bezieht sich auf die Basisklasseninstanz. Sie wird wie der Selbstbezeichner verwendet.

Virtuelle Methoden und Außerkraftsetzungen

Virtuelle Methoden (und Eigenschaften) funktionieren in F# im Vergleich zu anderen .NET-Sprachen etwas anders. Um ein neues virtuelles Element zu deklarieren, verwenden Sie das abstract Schlüsselwort. Dies geschieht unabhängig davon, ob Sie eine Standardimplementierung für diese Methode bereitstellen. Daher folgt eine vollständige Definition einer virtuellen Methode in einer Basisklasse folgendem Muster:

abstract member [method-name] : [type]

default [self-identifier].[method-name] [argument-list] = [method-body]

Und in einer abgeleiteten Klasse folgt eine Außerkraftsetzung dieser virtuellen Methode diesem Muster:

override [self-identifier].[method-name] [argument-list] = [method-body]

Wenn Sie die Standardimplementierung in der Basisklasse weglassen, wird die Basisklasse zu einer abstrakten Klasse.

Im folgenden Codebeispiel wird die Deklaration einer neuen virtuellen Methode function1 in einer Basisklasse und das Überschreiben in einer abgeleiteten Klasse veranschaulicht.

type MyClassBase1() =
    let mutable z = 0
    abstract member function1: int -> int

    default u.function1(a: int) =
        z <- z + a
        z

type MyClassDerived1() =
    inherit MyClassBase1()
    override u.function1(a: int) = a + 1

Konstruktoren und Vererbung

Der Konstruktor für die Basisklasse muss in der abgeleiteten Klasse aufgerufen werden. Die Argumente für den Basisklassenkonstruktor sind in der Argumentliste in der inherit-Klausel enthalten. Die verwendeten Werte müssen aus den Argumenten bestimmt werden, die dem abgeleiteten Klassenkonstruktor bereitgestellt werden.

Der folgende Code zeigt eine Basisklasse und eine abgeleitete Klasse, wobei die abgeleitete Klasse den Basisklassenkonstruktor in der Erbklausel aufruft:

type MyClassBase2(x: int) =
    let mutable z = x * x

    do
        for i in 1..z do
            printf "%d " i


type MyClassDerived2(y: int) =
    inherit MyClassBase2(y * 2)

    do
        for i in 1..y do
            printf "%d " i

Bei mehreren Konstruktoren kann der folgende Code verwendet werden. Die erste Zeile der abgeleiteten Klassenkonstruktoren ist die inherit Klausel, und die Felder werden als explizite Felder angezeigt, die mit dem val Schlüsselwort deklariert werden. Weitere Informationen finden Sie unter Explicit Fields: The val Keyword.

type BaseClass =
    val string1 : string
    new (str) = { string1 = str }
    new () = { string1 = "" }

type DerivedClass =
    inherit BaseClass

    val string2 : string
    new (str1, str2) = { inherit BaseClass(str1); string2 = str2 }
    new (str2) = { inherit BaseClass(); string2 = str2 }

let obj1 = DerivedClass("A", "B")
let obj2 = DerivedClass("A")

Alternativen zur Vererbung

In Fällen, in denen eine geringfügige Änderung eines Typs erforderlich ist, sollten Sie einen Objektausdruck als Alternative zur Vererbung verwenden. Im folgenden Beispiel wird die Verwendung eines Objektausdrucks als Alternative zum Erstellen eines neuen abgeleiteten Typs veranschaulicht:

open System

let object1 =
    { new Object() with
        override this.ToString() = "This overrides object.ToString()" }

printfn "%s" (object1.ToString())

Weitere Informationen zu Objektausdrücken finden Sie unter "Objektausdrücke".

Wenn Sie Objekthierarchien erstellen, sollten Sie eine diskriminierte Vereinigung anstelle der Vererbung verwenden. Diskriminierte Vereinigungen können auch verschiedene Verhaltensweisen verschiedener Objekte modellieren, die einen gemeinsamen Allgemeinen Typ aufweisen. Eine einzelne diskriminierte Vereinigung kann häufig die Notwendigkeit einer Reihe abgeleiteter Klassen beseitigen, die geringfügige Abweichungen voneinander sind. Informationen zu diskriminierten Gewerkschaften finden Sie unter Diskriminierte Gewerkschaften.

Siehe auch

  • Last updated on