F # - Vererbung

Eines der wichtigsten Konzepte in der objektorientierten Programmierung ist das der Vererbung. Durch Vererbung können wir eine Klasse in Bezug auf eine andere Klasse definieren, was das Erstellen und Verwalten einer Anwendung erleichtert. Dies bietet auch die Möglichkeit, die Codefunktionalität und die schnelle Implementierungszeit wiederzuverwenden.

Beim Erstellen einer Klasse kann der Programmierer festlegen, dass die neue Klasse die Mitglieder einer vorhandenen Klasse erben soll, anstatt vollständig neue Datenelemente und Elementfunktionen zu schreiben. Diese vorhandene Klasse wird als Basisklasse bezeichnet, und die neue Klasse wird als abgeleitete Klasse bezeichnet.

Die Idee der Vererbung implementiert die IS-A-Beziehung. Zum Beispiel ist Säugetier IS A-Tier, Hund IS-A-Säugetier, daher auch Hund IS-A-Tier und so weiter.

Basisklasse und Unterklasse

Eine Unterklasse wird von einer bereits definierten Basisklasse abgeleitet. Eine Unterklasse erbt die Mitglieder der Basisklasse und hat ihre eigenen Mitglieder.

Eine Unterklasse wird mit dem definiert inherit Schlüsselwort wie unten gezeigt -

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

In F # kann eine Klasse höchstens eine direkte Basisklasse haben. Wenn Sie keine Basisklasse angeben, verwenden Sie dieinherit Schlüsselwort, erbt die Klasse implizit von Object.

Bitte beachten Sie -

• Die Methoden und Mitglieder der Basisklasse stehen Benutzern der abgeleiteten Klasse wie den direkten Mitgliedern der abgeleiteten Klasse zur Verfügung.

• Lassen Sie Bindungen und Konstruktorparameter für eine Klasse privat sein und können daher nicht von abgeleiteten Klassen aus zugegriffen werden.

• Das Schlüsselwort basebezieht sich auf die Basisklasseninstanz. Es wird wie die Selbstkennung verwendet.

Beispiel

type Person(name) =
   member x.Name = name
   member x.Greet() = printfn "Hi, I'm %s" x.Name

type Student(name, studentID : int) =
   inherit Person(name)
   let mutable _GPA = 0.0
   member x.StudentID = studentID
   member x.GPA
      with get() = _GPA
      and set value = _GPA <- value

type Teacher(name, expertise : string) =
   inherit Person(name)

   let mutable _salary = 0.0
   member x.Salary
      with get() = _salary
      and set value = _salary <- value
   member x.Expertise = expertise

//using the subclasses
let p = new Person("Mohan")
let st = new Student("Zara", 1234)
let tr = new Teacher("Mariam", "Java")

p.Greet()
st.Greet()
tr.Greet()

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

Hi, I'm Mohan
Hi, I'm Zara
Hi, I'm Mariam

Methoden überschreiben

Sie können ein Standardverhalten einer Basisklassenmethode überschreiben und in der Unterklasse oder der abgeleiteten Klasse anders implementieren.

Methoden in F # können standardmäßig nicht überschrieben werden.

Um Methoden in einer abgeleiteten Klasse zu überschreiben, müssen Sie Ihre Methode mit der Option als überschreibbar deklarieren abstract und default Schlüsselwörter wie folgt -

type Person(name) =
   member x.Name = name
   abstract Greet : unit -> unit
   default x.Greet() = printfn "Hi, I'm %s" x.Name

Jetzt kann die Greet- Methode der Person-Klasse in abgeleiteten Klassen überschrieben werden. Das folgende Beispiel zeigt dies -

Beispiel

type Person(name) =
   member x.Name = name
   abstract Greet : unit -> unit
   default x.Greet() = printfn "Hi, I'm %s" x.Name

type Student(name, studentID : int) =
   inherit Person(name)

   let mutable _GPA = 0.0

   member x.StudentID = studentID
   member x.GPA
      with get() = _GPA
      and set value = _GPA <- value
   override x.Greet() = printfn "Student %s" x.Name

type Teacher(name, expertise : string) =
   inherit Person(name)
   let mutable _salary = 0.0
   member x.Salary
      with get() = _salary
      and set value = _salary <- value

   member x.Expertise = expertise
   override x.Greet() = printfn "Teacher %s." x.Name

//using the subclasses
let p = new Person("Mohan")
let st = new Student("Zara", 1234)
let tr = new Teacher("Mariam", "Java")

//default Greet
p.Greet()

//Overriden Greet
st.Greet()
tr.Greet()

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

Hi, I'm Mohan
Student Zara
Teacher Mariam.

Abstrakte Klasse

Manchmal müssen Sie eine unvollständige Implementierung eines Objekts bereitstellen, die in der Realität nicht implementiert werden sollte. Später sollte ein anderer Programmierer Unterklassen der abstrakten Klasse für eine vollständige Implementierung erstellen.

Beispielsweise wird die Personenklasse in einem Schulverwaltungssystem nicht benötigt. Es wird jedoch die Schüler- oder Lehrerklasse benötigt. In solchen Fällen können Sie die Person-Klasse als abstrakte Klasse deklarieren.

Das AbstractClass Das Attribut teilt dem Compiler mit, dass die Klasse einige abstrakte Mitglieder hat.

Sie können keine Instanz einer abstrakten Klasse erstellen, da die Klasse nicht vollständig implementiert ist.

Das folgende Beispiel zeigt dies -

Beispiel

[<AbstractClass>]
type Person(name) =
   member x.Name = name
   abstract Greet : unit -> unit

type Student(name, studentID : int) =
   inherit Person(name)
   let mutable _GPA = 0.0
   member x.StudentID = studentID
   member x.GPA
      with get() = _GPA
      and set value = _GPA <- value
   override x.Greet() = printfn "Student %s" x.Name

type Teacher(name, expertise : string) =
   inherit Person(name)
   let mutable _salary = 0.0
   member x.Salary
      with get() = _salary
      and set value = _salary <- value
   member x.Expertise = expertise
   override x.Greet() = printfn "Teacher %s." x.Name

let st = new Student("Zara", 1234)
let tr = new Teacher("Mariam", "Java")

//Overriden Greet
st.Greet()
tr.Greet()

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

Student Zara
Teacher Mariam.