# 接口

在 C# 语言中，类之间的继承关系仅支持单重继承，而接口是为了实现多重继承关系设计的。

一个类能同时实现多个接口，还能在实现接口的同时再继承其他类，并且接口之间也可以继承。

无论是表示类之间的继承还是类实现接口、接口之间的继承，都使用“:”来表示。

接口定义的语法形式如下。

```C#
interface  接口名称
{
    接口成员；
}
```

其中：

1. 接口名称
   通常是以 I 开头，再加上其他的单词构成。例如创建一个计算的接口，可以命名为 ICompute。
2. 接口成员
   接口中定义的成员与类中定义的成员类似。

接口中定义的成员必须满足以下要求。

- 接口中的成员不允许使用 public、private、protected、internal 访问修饰符。
- 接口中的成员不允许使用 static、virtual、abstract、sealed 修饰符。
- 在接口中不能定义字段。
- 在接口中定义的方法不能包含方法体。

## 实现接口

接口的实现实际上和类之间的继承是一样的，也是重写了接口中的方法，让其有了具体的实现内容。

但需要注意的是，在类中实现一个接口时必须将接口中的所有成员都实现，否则该类必须声明为抽象类，并将接口中未实现的成员以抽象方式实现。

在 C# 语言中实现接口的具体语法形式如下。

```C#
class  类名 : 接口名
{
    //类中的成员以及实现接口中的成员
}
```

在实现接口的成员时有两种方式，一种是隐式实现接口成员，一种是显式实现接口成员。

在实际应用中隐式实现接口的方式比较常用，由于在接口中定义的成员默认是 public 类型的，隐式实现接口成员是将接口的所有成员以 public 访问修饰符修饰。

显式实现接口是指在实现接口时所实现的成员名称前含有接口名称作为前缀。

需要注意的是使用显式实现接口的成员不能再使用修饰符修饰，即 public、abstract、virtual、 override 等。

接口与抽象类的区别入下表所示。

| 接口                                                                                                                               | 抽象类                                                                                              |
| ---------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
| 在接口中仅能定义成员，但不能有具体的实现。                                                                                         | 抽象类除了抽象成员以外，其他成员允许有具体的实现。                                                  |
| 在接口中不能声明字段，并且不能声明任何私有成员，成员不能包含任何修饰符。                                                           | 在抽象类中能声明任意成员，并能使用任何修饰符来修饰。                                                |
| 接口能使用类或者结构体来继承。                                                                                                     | 抽象类仅能使用类继承。                                                                              |
| 在使用类来实现接口时，必须隐式或显式地实现接口中的所有成员，否则需要将实现类定义为抽象类，并将接口中未实现的成员以抽象的方式实现。 | 在使用类来继承抽象 类时允许实现全部或部分成员，但仅实现其中的部分成员，其实现类必须也定义为抽象类。 |
| 一个接口允许继承多个接口。                                                                                                         | 一个类只能有一个父类。                                                                              |

## 接口中多态的实现

使用接口实现多态 需要满足以下两个条件。

- 定义接口并使用类实现了接口中的成员。
- 创建接口的实例指向不同的实现类对象。

## 继承

## 继承和派生

继承是面向对象程序设计中最重要的概念之一。

在 C# 语言中仅支持单重继承，主要用于解决代码的重用问题。

继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。

同时也有利于重用代码和节省开发时间。

当创建一个类时，我们不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。

这个已有的类被称为的基类，这个新的类被称为派生类。

继承的思想实现了属于（IS-A）关系。例如，哺乳动物属于（IS-A）动物，狗属于（IS-A）哺乳动物，因此狗属于（IS-A）动物。

C# 继承的特点

- 派生类是对基类的扩展，派生类可以添加新的成员，但不能移除已经继承的成员的定义。
- 继承是可以传递的。如果 C 从 B 中派生，B 又从 A 中派生，那么 C 不仅继承了 B 中声明的成员，同样也继承了 A 中声明的成员。
- 构造函数和析构函数不能被继承，除此之外其他成员能被继承。基类中成员的访问方式只能决定派生类能否访问它们。
- 派生类如果定义了与继承而来的成员同名的新成员，那么就可以覆盖已继承的成员，但这并不是删除了这些成员，只是不能再访问这些成员。
- 类可以定义虚方法、虚属性及虚索引指示器，它的派生类能够重载这些成员，从而使类可以展示出多态性。
- 派生类只能从一个类中继承，可以通过接口来实现多重继承。

为了将继承关系灵活运地用到程序设计中，在 C# 语言中提供了接口来解决多重继承的关系。

## Object 类

Object 类是 C# 语言中最原始、最重要的类，是所有类的“祖先”，每个 C# 类都是它的子类，它实现了每个类都必须具有的基本方法。

这里指的“所有类”，即不管是 C# 系统所提供的标准类，还是用户自行編写的类，都是从 Object 类直接或间接继承而来，它是类层次结构中的顶级类，即 C# 树型类层次结构的“根”。

当編程者定义一个类时没有使用关键字 Extends 指明它的父类，则編译器认为该类从 Object 类继承而来。

Object 类中的属性和方法可以被用到任何类。

但 Object 类的方法所实现的功能很有限，都是由编程者在自行设计的 class 类型的类体内编写与原型完全相同的方法来覆盖它们，以实现用户所要求的有用功能。

在 Object 类中提供了 4 个常用的方法，即 Equals、GetHashCode、GetType 以及 ToString 方法。

既然任何一个类都继承了 Object 类，这 4 个方法也可以被任何类使用或重写。

### Equals 方法：判断两个对象是否相等

C# Equals 方法主要用于比较两个对象是否相等，如果相等则返回 True,否则返回 False。

如果是引用类型的对象，则用于判断两个对象是否引用了同一个对象。

在 C# 语言中，Equals 方法提供了两个，一个是静态的，一个是非静态的，具体的定义如下。

```C#
Equals (object ol, object o2); //静态方法
Equals (object o); //非静态方法
```

### GetHashCode 方法：获取哈希码

GetHashCode 方法返回当前 System.Object 的哈希代码，每个对象的哈希值都是固定的。

该方法不含有任何参数，并且不是静态方法，因此需要使用实例来调用该方法。

由于该方法是在 Object 类中定义的，因此任何对象都可以直接调用该方法。

### GetType 方法：获取对象 type 类型

GetType 方法用于获取当前实例的类型，返回值为 System.Type 类型。

C# GetType 方法不含任何参数，是非静态方法。

### ToString 方法：返回对象实例的字符串

ToString 方法返回一个对象实例的字符串，在默认情况下将返回类类型的限定名。

C# 中几乎所有的类型都派生自 Object，所以如果当前类型没有重写 ToString() 方法的情况下，调用 ToString() 方法，默认返回当前类型的名称。

任何类都可以重写 ToString 方法，返回自定义的字符串。

对于其他的值类型，则为将值转换为字符串类型的值。

## base 关键字：调用父类成员方法

在 C# 语言中子类中定义的同名方法相当于在子类中重新定义了一个方法，在子类中的对象是调用不到父类中的同名方法的，调用的是子类中的方法。

因此也经常说成是将父类中的同名方法隐藏了。

在继承的关系中，子类如果需要调用父类中的成员可以借助 base 关键字来完成，具体的用法如下。

```C#
base. 父类成员
```

如果在同名的方法中使用 base 关键字调用父类中的方法，则相当于把父类中的方法内容复制到该方法中。

this 关键字代表的是当前类的对象，而 base 关键字代表的是父类中的对象。

## virtual 关键字

virtual 是虚拟的含义，在 C# 语言中，默认情况下类中的成员都是非虚拟的，通常将类中的成员定义成虚拟的，表示这些成员将会在继承后重写其中的内容。

virtual 关键字能修饰方法、属性、索引器以及事件等，用到父类的成员中。

使用 virtual 关键字修饰属性和方法的语法形式如下。

```C#
//修饰属性
public  virtual  数据类型  属性名{get; set; }
```

```C#
//修饰方法
访问修饰符  virtual  返回值类型方法名
{
    语句块；
}
```

此外，virtual 关键字既可以添加到访问修饰符的后面，也可以添加到访问修饰符的前面，但实际应用中习惯将该关键字放到访问修饰符的后面。

子类继承父类后能重写父类中的成员，重写的关键字是 override。

所谓重写是指子类和父类的成员定义一致，仅在子类中增加了 override 关键字修饰成员。

## abstract：声明抽象类或抽象方法

abstract 关键字代表的是抽象的，使用该关键字能修饰类和方法，修饰的方法被称为抽象方法、修饰的类被称为抽象类。

在 C# 语言中抽象方法是一种不带方法体的方法，仅包含方法的定义，语法形式如下。

```C#
访问修饰符  abstract  方法返回值类型  方法名(参数列表);
```

其中，当 abstract 用于修饰方法时，也可以将 abstract 放到访问修饰符的前面。

抽象方法定义后面的“;”符号是必须保留的。需要注意的是，抽象方法必须定义在抽象类中。

在定义抽象类时，若使用 abstract 修饰类，将其放到 class 关键字的前面，语法形式如下。

```C#
访问修饰符  abstract class  类名
{
    //类成员
}
```

其中“abstract”关键字也可以放到访问修饰符的前面。

在抽象类中可以定义抽象方法，也可以定义非抽象方法。

通常抽象类会被其他类继承，并重写其中的抽象方法或者虚方法。

此外，尽管在抽象类中仍然能定义构造器，但抽象类不能实例化，即不能使用如下语句。

```C#
new  抽象类的名称();
```

## sealed：声明密封类或密封方法

sealed 关键字的含义是密封的，使用该关键字能修饰类或者类中的方法，修饰的类被称为密封类、修饰的方法被称为密封方法。

但是密封方法必须出现在子类中，并且是子类重写的父类方法，即 sealed 关键字必须与 override 关键字一起使用。

密封类不能被继承，密封方法不能被重写。在实际应用中，在发布的软件产品里有些类或方法不希望再被继承或重写，可以将其定义为密封类或密封方法。

## 多态

在 C# 语言中多态称为运行时多态，也就是在程序运行时自动让父类的实例调用子类中重写的 方法，它并不是在程序编译阶段完成的。

使用继承实现多态，实际上是指子类在继承父类后，重写了父类的虚方法或抽象方法。

在创建父类的对象指向每一个子类的时候，根据调用的不同子类中重写的方法产生了不同的执行效果。

总而言之，使用继承实现多态必须满足以下两个条件。

- 子类在继承父类时必须有重写的父类的方法。
- 在调用重写的方法时，必须创建父类的对象指向子类(即子类转换成父类)。
