F＃ - 继承( Inheritance)
面向对象编程中最重要的概念之一是继承。 继承允许我们根据另一个类定义一个类，这使得创建和维护应用程序变得更容易。 这也提供了重用代码功能和快速实现时间的机会。
在创建类时，程序员可以指定新类应该继承现有类的成员，而不是编写全新的数据成员和成员函数。 此现有类称为基类，新类称为派生类。
继承的想法实现了IS-A关系。 例如，哺乳动物是动物，狗是IS-A哺乳动物，因此也是狗IS-A动物，等等。
基类和子类
子类派生自已定义的基类。 子类继承基类的成员，并且具有自己的成员。
使用inherit关键字定义子类，如下所示 -
type MyDerived(...) =
inherit MyBase(...)
在F＃中，一个类最多只能有一个直接基类。 如果未使用inherit关键字指定基类，则该类将隐式继承自Object。
请注意 -
派生类的用户可以使用基类的方法和成员，例如派生类的直接成员。
让绑定和构造函数参数对类是私有的，因此无法从派生类访问。
关键字base指的是基类实例。 它像自我标识符一样使用。
例子 (Example)
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方法。 以下示例演示了这一点 -
例子 (Example)
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属性告诉编译器该类有一些抽象成员。
您无法创建抽象类的实例，因为该类未完全实现。
以下示例演示了这一点 -
例子 (Example)
[<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.
