F# - 继承

面向对象编程中最重要的概念之一是继承。 继承允许我们根据另一个类来定义一个类，这使得创建和维护应用程序变得更加容易。 这也提供了重用代码功能和快速实施时间的机会。

创建类时，程序员可以指定新类继承现有类的成员，而不是编写全新的数据成员和成员函数。 这个现有类称为基类，新类称为派生类。

继承的思想实现了IS-A关系。 例如，哺乳动物是一种动物，狗是一种哺乳动物，因此狗也是一种动物，依此类推。

基类和子类

子类是从已经定义的基类派生的。 子类继承基类的成员，并且拥有自己的成员。

使用inherit关键字定义子类，如下所示 −

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

在 F# 中，一个类最多可以有一个直接基类。 如果不使用inherit关键字指定基类，则该类隐式继承自Object。

请注意 −

• 派生类的用户可以使用基类的方法和成员，就像派生类的直接成员一样。

• 让绑定和构造函数参数对于类来说是私有的，因此不能从派生类访问。

• 关键字base指的是基类实例。 它的使用方式与自我标识符类似。

示例

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()

当您编译并执行该程序时，它会产生以下输出 −

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

重写方法

您可以重写基类方法的默认行为，并在子类或派生类中以不同方式实现它。

默认情况下，F# 中的方法不可重写。

要重写派生类中的方法，您必须使用 abstract 和 default 关键字将您的方法声明为可重写，如下所示 −

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

现在，Person 类的 Greet 方法可以在派生类中重写。 下面的例子演示了这一点 −

示例

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()

当您编译并执行该程序时，它会产生以下输出 −

Hi, I'm Mohan
Student Zara
Teacher Mariam.

抽象类

有时您需要提供对象的不完整实现，而这在现实中不应该实现。 稍后，其他一些程序员应该创建抽象类的子类以实现完整的实现。

例如，学校管理系统中不需要 Person 类。 但是，将需要学生或教师课程。 在这种情况下，您可以将 Person 类声明为抽象类。

AbstractClass 属性告诉编译器该类有一些抽象成员。

您无法创建抽象类的实例，因为该类未完全实现。

以下示例演示了这一点 −

示例

[<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()

当您编译并执行该程序时，它会产生以下输出 −

Student Zara
Teacher Mariam.