四、多级继承
一些面向对象语言允许一个类从多个基类中继承，而另一些面向对象语言只允许从一个类继承，但可以随意从几个接口或纯抽象类中继承。
只有C++支持多级继承，许多程序员对此褒贬不一。多级继承常会引起继承来的类之间的混乱，继承而来的方法往往没有唯一性，所以C#中类的继承只可以是一个,即子类只能派生于一个父类，而有时你必须继承多个类的特性，为了实现多重继承必须使用接口技术，下面是对接口的多重继承进行介绍：
using System ;
//定义一个描述点的接口
interface IPoint
{
int x {
get ;
set ;
}
int y {
get ;
set ;
}
}
interface IPoint2
{
int y {
get ;
set ;
}
}
//在point中继承了两个父类接口,并分别使用了两个父类接口的方法
class Point:IPoint,IPoint2
{
//定义两个类内部访问的私有成员变量
private int pX ;
private int pY ;
public Point(int x,int y) {
pX=x ;
pY=y ;
}
//定义的属性,IPoint接口方法实现
public int x
{
get
{ return pX ; }
set
{ pX =value ; }
}
//IPoint1接口方法实现
public int y
{
get
{ return pY ; }
set
{ pY =value ; }
}
}
class Test
{
private static void OutPut( IPoint p )
{ Console.WriteLine("x={0},y={1}",p.x,p.y) ; }
public static void Main( ) {
Point p =new Point(15,30) ;
Console.Write("The New Point is:") ;
OutPut( p ) ;
string myName =Console.ReadLine( ) ;
Console.Write("my name is {0}", myName) ;
}
}
五、继承与访问修饰符
访问修饰符是一些关键字，用于指定声明的成员或类型的可访问性。类的继承中有四个访问修饰符： public protected internal private。使用这些访问修饰符可指定下列五个可访问性级别： public protected internal internal protected private。
声明的可访问性 意义
public 访问不受限制。
protected 访问仅限于包含类或从包含类派生的类型。
internal 访问仅限于当前项目。
protected internal 访问仅限于从包含类派生的当前项目或类型。
private 访问仅限于包含类型。
1、继承中关于可访问域的一些问题
基类的所有成员（实例构造函数、析构函数和静态构造函数除外）都由派生类型继承。这甚至包括基类的私有成员。但是，私有成员的可访问域只包括声明该成员的类型的程序文本。在下面的示例中
class A
{
int x ;
static void F(B b) {
b.x = 1 ; // 对
}
}
class B: A
{
static void F(B b) {
b.x = 1 ; // 错误
}
}
类 B 继承类 A 的私有成员 x。因为该成员是私有的，所以只能在 A 的"类体"中对它进行访问。因此，对 b.x 的访问在 A.F 方法中取得了成功，在 B.F 方法中却失败了。
2、继承中关于属性的一些问题
和类的成员方法一样，我们也可以定义属性的重载、虚属性、抽象属性以及密封属性的概念。与类和方法一样，属性的修饰也应符合下列规则：
属性的重载
1. 在派生类中使用修饰符的属性，表示对基类中的同名属性进行重载。
2. 在重载的声明中，属性的名称、类型、访问修饰符都应该与基类中被继承的属性一致。
3. 如果基类的属性只有一个属性访问器，重载后的属性也应只有一个。但如果基类的属性同时包含get 和set 属性访问器，重载后的属性可以只有一个，也可以同时有两个属性访问器。
注意：与方法重载不同的是，属性的重载声明实际上并没有声明新的属性，而只是为已有的虚属性提供访问器的具体实现。
虚属性
1. 使用virtual 修饰符声明的属性为虚属性。
2. 虚属性的访问器包括get 访问器和set 访问器，同样也是虚的。
抽象属性
1. 使用abstract 修饰符声明的属性为抽象属性。
2. 抽象属性的访问器也是虚的，而且没有提供访问器的具体实现。这就要求在非虚的派生类中，由派生类自己通过重载属性来提供对访问器的具体实现。
3. abstract 和override 修饰符的同时使用，不但表示属性是抽象的，。而且它重载了基类中的虚属性这时属性的访问器也是抽象的。
4. 抽象属性只允许在抽象类中声明。
5. 除了同时使用abstract 和override 修饰符这种情况之外，static, virtual, override和abstract 修饰符中任意两个不能再同时出现。
密封属性
1. 使用sealed 修饰符声明的属性为密封属性。类的密封属性不允许在派生类中被继承。密封属性的访问器同样也是密封的。
2. 属性声明时如果有sealed 修饰符，同时也必须要有override 修饰符。
从上面可以看出，属性的这些规则与方法十分类似。对于属性的访问器，我们可以把get 访问器看成是一个与属性修饰符相同、没有参数、返回值为属性的值类型的方法，把set 访问器看成是一个与属性修饰符相同、仅含有一个value 参数、返回类型为void 的方法。看下面的程序：
using System ;
public enum sex
{ woman, man, } ;
abstract public class People
{
private string s_name;
public virtual string Name
{
get
{ return s_name ; }
}
private sex m_sex ;
public virtual sex Sex
{
get
{ return m_sex ; }
protected string s_card;
public abstract string Card
{ get; set; }
}
上面的例子中声明了"人"这个类，人的姓名Name 和性别Sex 是两个只读的虚属性：身份证号Card 是一个抽象属性，允许读写，因为类People 中包含了抽象属性Card，所以People 必须声明是抽象的。下面我们为住宿的客人编写一个类类从People 中继承。再看下面的程序：
class Customer: People
{
string s_no ;
int i_day ;
public string No
{
get
{ return s_no ; }
set
{
if (s_no != value)
s_no = value;
}
}
public int Day
{
get
{ return i_day ; }
set
{
if (i_day != value)
i_day = value;
}
}
public override string Name
{
get { return base.Name; }
}
public override sex Sex
{
get { return base.Sex }
}
public override string Card
{
get
{ return s_ card ; }
set
{ s_ card = value ; }
}
}
在类Customer 中，属性Name、 Sex 和Card 的声明都加上了override 修饰符，属性的声明都与基类People 中保持一致。Name 和Sex 的get 访问器，Card 的get 和set访问器都使用了base 关键字来访问基类People 中的访问器属性。Card 的声明重载了基类People 中的抽象访问器。这样，在Customer 类中没有抽象成员的存在，Customer可以是非虚的
3、继承中对使用可访问性级别的限制
声明类型时，最重要的是查看该类型是否必须"至少"与其他成员或类型"具有同样的可访问性"。例如，直接基类必须至少与派生类具有同样的可访问性。以下声明将导致编译器错误，因为基类 BaseClass 的可访问性小于 MyClass：
class BaseClass {...}
public class MyClass: BaseClass {...} // Error
下表汇总了对使用声明的可访问性级别的限制。
上下文 备注
类 类类型的直接基类必须至少与类类型本身具有同样的可访问性。
接口 接口类型的显式基接口必须至少与接口类型本身具有同样的可访问性。
委托 委托类型的返回类型和参数类型必须至少与委托类型本身具有同样的可访问性。
常数 常数的类型必须至少与常数本身具有同样的可访问性。
字段 字段的类型必须与至少字段本身具有同样的可访问性。
方法 方法的返回类型和参数类型必须至少与方法本身具有同样的可访问性。
属性 属性的类型必须至少与属性本身具有同样的可访问性。
事件 事件的类型必须至少与事件本身具有同样的可访问性。
索引器 索引器的类型和参数类型必须至少与索引器本身具有同样的可访问性。
运算符 运算符的返回类型和参数类型必须至少与运算符本身具有同样的可访问性。
构造函数 构造函数的参数类型必须至少与构造函数本身具有同样的可访问性。
示例：以下示例包含不同类型的错误声明。每个声明后的注释指示了预期的编译器错误。
using System ;
delegate int MyDelegate( ) ;
class B
{ // 定义一个私有的函数:
static int MyPrivateMethod()
{ return 0 ; }
}
public class A
{ // 字段定义:
public B myField = new B();// 错误: 类型B与A字段A.myField级别不同
// 构造函数:
public readonly B myConst = new B(); //错误: 类型B是仅读的
//方法:
public B MyMethod()
{
return new B();
}
//属性:
public B MyProp
{
set { }
}
public static B operator + (A m1, B m2)
{
return new B();
}
static void Main()
{
Console.Write("Compiled successfully");
}
}
……