第四章-继承


1>实现继承
1）要声明一个类派生于另一个类，可以使用下面的语法：

```
class MyDerivedClass : MyBaseClass
{
// functions and data members here
}
```
2）类(或结构)也派生于接口，则用逗号分隔开基类和接口：

```
public class MyDerivedClass : MyBaseClass, IInterface1, IInterface2
{
//etc.
}
```
结构，语法如下：

```
public struct MyDerivedStruct : IInterface1, IIn
4000
terface2
{
//etc.
}
```

在类定义中没有指定基类， C#编译器就假定 System.Object 是基类。

```
class MyClass : Object //derives from System.Object
{
//etc.
}
```

```
class MyClass //derives from System.Object
{
//etc.
}
```

2>虚方法
1)把一个基类函数声明为 virtual，该函数就可以在派生类中重写了：

```
class MyBaseClass
{
public virtual string VirtualMethod()
{
return "This method is virtual and defined in MyBaseClass";
}
}
```
也可以把属性声明为 virtual。对于虚属性或重写属性，语法与非虚属性是相同的，但要在定义中加上关键字 virtual，其语法如下所示：

```
public virtual string ForeName
{
get { return foreName; }
set { foreName = value; }
}
private string foreName;
```
2)重写
(1) C#要求在派生类的函数重写另一个函数时，要使用 override 关键字显式声明：

```
class MyDerivedClass : MyBaseClass
{
public override string VirtualMethod()
{
return "This method is an override defined in MyDerivedClass";
}
}
```

3>隐藏方法
1)如果签名相同的方法在基类和派生类中都进行了声明，但该方法没有声明为 virtual 和override，派生类方法就会隐藏基类方法。
2)C#中，应使用 new 关键字声明我们要隐藏一个方法

```
class MyDerivedClass : HisBaseClass
{
public new int MyGroovyMethod()
{
// some groovy implementation
return 0;
}
}
```
4>抽象类和抽象函数
1)C#允许把类和函数声明为 abstract，抽象类不能实例化，而抽象函数没有执行代码，必须在非抽象的派生类中重写。如果类包含抽象函数，该类将也
是抽象的，也必须声明为抽象的：

```
abstract class Building
{
public abstract decimal CalculateHeatingCost(); // abstract method
}
```
在类声明的成员字段上使用=<value>，提供初始值：

```
abstract class Building
{
private bool damaged = false; // field
public abstract decimal CalculateHeatingCost(); // abstract method
}
```
5>密封类和密封方法
1)把类和方法声明为 sealed。对于类来说，这表示不能继承该类；对于方法来说，这表示不能重写该方法。

```
sealed class FinalClass
{
// etc
}
class DerivedClass : FinalClass
compilation error
{
// etc
}
```
2)把方法声明为 sealed 也可以实现类似的目的

```
class MyClass
{
public sealed override void FinalMethod()
{
// etc.
}
}
class DerivedClass : MyClass
{
public override void FinalMethod()
{
}
}
```
在方法上使用 sealed 关键字是没有意义的，除非该方法本身是某个基类上另一个方法的重写形式。如果定义一个新方法，但不想让别人重写它，首先就不要把它声明为 virtual。但如果要重写某个基类方法， sealed 关键字就提供了一种方式，可以确保为方法提供的重写代码是最终的代码，其他人不能再重写它。

6>修饰符
1)可见性修饰符

```
修 饰 符              应 用 于               说 明
public             所有的类型或成员        任何代码均可以访问该方法
protected        类型和内嵌类型的所有成员   只有派生的类型能访问该方法
internal       类型和内嵌类型的所有成员 只能在包含它的程序集中访问该方法
private        所有的类型或成员         只能在它所属的类型中访问该方法
protected internal 类型和内嵌类型的所有成员  只能在包含它的程序集和派生
                                         类型的代码中访问该方法
```
1,不能把类型定义为 protected、 private 和 protected internal，因为这些修饰符对于包含在命名空间中的类型来说是没有意义的。
2)其他修饰符

```
修 饰 符          应 用 于                 说 明
new              函数成员           成员用相同的签名隐藏继承的成员
static           所有的成员         成员不在类的具体实例上执行
virtual          仅类和函数成员      成员可以由派生类重写
abstract         仅函数成员 虚拟成员定义了成员的签名，但没有提供实现代码
override         仅函数成员      成员重写了继承的虚拟或抽象成员
sealed           类       成员重写了继承的虚拟成员，但继承该类的任何类
                          都不能重写该成员。该修饰符必须与override一起使用       

extern        仅静态[DllImport]方法    成员在外部用另一种语言实现
```
internal与 public 类似，但访问仅限于同一个程序集中的其他代码使用 internal 可以确保编写的其他类都能访问某一成员，但同时其他公司编
写的其他代码不能访问它们。