C#语言 基础

C#语言 基础

http://blog.csdn.net/mousebaby808/category/665050.aspx?PageNumber=2
C#语言 第一部分 面向对象 （一） 类和Main方法

通过“面向对象基本原理”的学习，我们应该了解如何从“面向过程”过渡到“面向对象”，也能基本了解面向 对象编程的一些优点，这一章，我们进入到一门纯粹的面向对象语言C#语言的学习。

C# 语言是.net平台的一部分，.net平台提供了一种叫做“公共语言”的中间语言，几乎各种语言都可以映射倒公共语言上，例如 C++，Visual Basic，JScript等，C#是微软专门为.net平台开发的，该语言语法简洁，功能强大，已经成为一门重要的主流开发语言。

关于 C#语言的特色，可以参考各类教科书或查阅网络资料。这里我们只针对C#语言本身进行介绍，关于语言的其它方面，请大伙自学。

我们从最基本的HelloWorld程序开始，了解一下C#编程的基本结构。
1 // using关键字的作用是引入一个“外部程序集”，System是微软提供的.net平台最基本程序集，所有 的.net程序都必须引用此程序集2 using System;3 4 // .net规范允许每一个类都属于一个命名空间5 // 命名空间的主要作用是用来防止出现“名字冲突”，即处于不同命名空间的类， 可以具有相同的类名6 // 命名空间还可以用来组织类的层次，使用 组织名.公司名.项目名.模块名 形成一个命名空间，可以有效地隔离不同的类7 namespace Edu.Study.OO.MainMethod {8 9 /// <summary>10 /// C#作为一种“纯面向对象”语言，类是所有代码的基础，使用关键字class可以定义一个类11 /// </summary>12 class Program {13 14 /// <summary>15 /// 在任意类中声明Main方法，该方法即可作为项目的启动入口点，程序从 Main方法开始运行。16 /// Main 方法的标准写法：使用static关键字修饰，返回类型为void 类型，方法民为Main（首字母大写），具有一个字符串数组类型的参数17 /// </summary>18 /// <param name="args"> 控制台参数，该参数由程序的运行者从控制台传入，由程序处理 </param>19 static void Main(string[] args) {20 // Console表示控制台，WriteLine方法表示“输出一行”，参数 为要输出的字符串21 Console.WriteLine("Hello World");22 }23 }24 }

可以看到，C#依旧秉承了C和C++的很多语法，另外还带有些许Java的影子，C#是一门简单易学的编程语言，只要努力学习，都可以掌握这门优秀 的编程语言。
C#语言 第一部分 面向对象 （二） 类

类是面向对象的基础，类表现出的最基本特性是其“封装性”。

类是某一些具有相同属性和行为对象的抽象。例如：波斯猫、野猫、家猫、花猫都具有相同的属性和行为，所以被抽象成为猫类。

类具有属性和方法，表示这个类所代表的对象具有的特性和行为。从类实例化对象后，对象就可以给类中定义的属性“赋值”或运行类中定义的方法，属性和 方法和每个对象相关，即相同类的不同的对象具有相同的属性，但属性的属性值可以不同；具有相同的方法，但方法运行的结果可以不同。

类需要将和其相关的属性和方法“封装”起来，并和对象进行绑定。

看下面的例子，自行理解：
1 using System;2 3 namespace Edu.Study.OO.Class {4 5 /// <summary>6 /// 定义一个Person类，表示人7 /// </summary>8 public class Person {9 10 /// <summary>11 /// 在类中定义的变量称为“字段”12 /// name为一个string类型的字段，保存人的名字13 /// </summary>14 private string name;15 16 /// <summary>17 /// 保存年龄18 /// </summary>19 private int age;20 21 /// <summary>22 /// 保存性别，true为男性，false为女性23 /// </summary>24 private bool sex;25 26 /// <summary>27 /// 属性定义，在面向对象编程里，字段作为保存属性值的变量，而属性则需要使用特殊的“行为”来表现28 /// 一般来说，一对get/set行为用来展现对象的属性，其中get用于获取该对象的属性；set用于设置该对象的属 性29 /// get/set称为属性的“访问器”30 /// 31 /// 姓名属性32 /// </summary>33 public string Name {34 get {35 // get访问器必须返回一个值，作为该属性的“属性值36 return this.name;37 38 // . 运算符的作用是访问某个对象的属性或方法39 // this关键字表示“当前实例”，即哪一个对象正在操作属性访问 器，this就表示哪个对象40 // 所以一般说法，this表示“当前对象”，使用this.访问的是“声明在 本类中”的属性和方法41 }42 set {43 // set访问器具有一个局部变量value，该值是从外部设置给该属性的值44 this.name = value ;45 }46 47 // 属性的基本要求：get访问器必须返回一个值，该值类型和属性类型相 同；set访问器可以设置一个值，这个值保存在什么地方倒无所谓48 }49 50 /// <summary>51 /// 年龄属性52 /// </summary>53 public int Age {54 get {55 return age;56 }57 set {58 age = value ;59 }60 }61 62 /// <summary>63 /// 性别属性64 /// </summary>65 public bool Sex {66 get {67 return sex;68 }69 set {70 sex = value ;71 }72 }73 74 /// <summary>75 /// 显示个人信息的方法76 /// </summary>77 public void ShowMe () {78 // 输出，其中：79 // 形如{0}, {1}称为“占位符”，当输出内容时，这些占位符会被第一个参数之后的参数 “依次取代”，例如：80 // {0}会被this.Name的值取代，即被第一个参数取代81 // {1}会被 this.Sex的值取代，即被第二个参数取代82 // {n}会被第n+1个参数取代。83 // 使用this.Name，此时属性Name的get访问器会运行，返回 Name属性的属性值，其它属性同理84 Console.WriteLine("姓名：{0}，性别：{1}，年龄：{2}岁。" , this.Name, this.Sex, this.Age) ;85 }86 87 // 字段、属性和方法前面，都可以使用public, protected, private和internal这四种访问修饰符来修饰88 // public表示字段、属性或方法为“公开”，公开的成员不仅可以被类中的 其它成员访问到，也可以通过这个类的对象访问到89 // private表示字段、属性或方法为“私有”，私有的成员只能被类中的其 它成员访问到，无法通过类的对象访问到90 // protected和internal稍候介绍91 }92 93 class Program {94 static void Main(string[] args) {95 // 通过new运算符可以实例化一个对象96 // 实例化Person类的对象，保存在person变量中97 Person p1 = new Person();98 Person p2 = new Person();99 100 // 设置person对象的各个属性，使用 person.Name = " 王宝宝"，Name属性的set访问器会被运行，等号右边的值"王宝宝"传递给set访问器的value变量101 p1.Name = "王宝宝";102 p1.Age = 21;103 p1.Sex = false;104 105 p2.Name = "李大大";106 p2.Age = 18;107 p2.Sex = true;108 109 // 使用 . 操作符访问 person对象的ShowMe方法，显示结果110 p1.ShowMe();111 p2.ShowMe();112 113 }114 }115 }
C#语言 第一部分 面向对象 （三） 对象的构造

上一章我们介绍了一个Person 类，它可以正常工作，但从逻辑上存在很多问题。

首先我们注意到，Person类对象实例化完毕后，我们才去确定其属性，如 Name，Sex，Age属性。但客观情况下，这些属性应该是同对象生成 一起赋值的。

一句话，当对象被实例化的同时，对象的属性就应当有初始值，反映到代码中，就是“用来保存属性值的字段应该有初始值”

构造器，也成为构造方法，构造函数，就是专门用来做这件事情的。

一个类可以有0或多个构造器，在有多个构造器的情况里，各个构造器的参数必须不同。

在 C#类中，有这样一类特殊的方法，没有返回值类型，方法名必须和类名相同，可以有参数列表。这类方法就叫做构造器，构造器通过new操作符指定， 在实例化对象的同时运行。

我们用构造器来改造上一章讲到的Person类。
1 using System;2 using System.Collections.Generic;3 using System.Linq;4 using System.Text;5 6 namespace Edu.Study.OO.Constructor {7 8 /// <summary>9 /// 人类，这次我们修改一下Person类10 /// 在Person类生成对象的同时，Name属性，Sex属性和Age属性的值就应该确 定，而不应该在生成对象后再进行设置，这是不符合客观规律的。11 /// 在对象实例化的同时对属性进行设置，就要用到“构造器”12 /// </summary>13 public class Person {14 15 /// <summary>16 /// name 为一个string类型的字段，保存人的名字17 /// </summary>18 private string name;19 20 /// <summary>21 /// 保存年龄22 /// </summary>23 private int age;24 25 /// <summary>26 /// 保存性别，true为男性，false为女性27 /// </summary>28 private bool sex;29 30 /// <summary>31 /// 没有参数的构造器称为“默认”构造器32 /// 如果一个类没有提供任何形式的构造器，则C#编译器会提供给该类一个默认构造器33 /// 默认构造器应该赋予所有的字段“默认值”，系统提供的默认构造器将所有的字段设置为“类型默认值”，即0或null34 /// </summary>35 public Person() {36 this.name = "小王";37 this.age = 22;38 this.sex = true;39 }40 41 /// <summary>42 /// 带有参数的构造器43 /// </summary>44 public Person(string name, int age, bool sex) {45 this.Name = name;46 this.Age = age;47 this.sex = sex; // 这里，Sex属性48 }49 50 /// <summary>51 /// 带有部分参数的构造器52 /// </summary>53 public Person(int age, bool sex) {54 this.Name = "小王";55 this.Age = age;56 this.sex = sex; // 这里，Sex属性57 }58 59 /// <summary>60 /// 带有部分参数的构造器61 /// </summary>62 public Person(bool sex) {63 this.Name = "小王";64 this.Age = 22;65 this.sex = sex; // 这里，Sex属性66 }67 68 /// <summary>69 /// 姓名属性70 /// </summary>71 public string Name {72 get {73 // get访问器必须返回一个值，作为该属性的“属性值74 return this.name;75 }76 set {77 // set访问器具有一个局部变量value，该值是从外部设置给该属性的值78 this.name = value;79 }80 }81 82 /// <summary>83 /// 年龄属性84 /// </summary>85 public int Age {86 get {87 return age;88 }89 set {90 age = value;91 }92 }93 94 /// <summary>95 /// 性别属性，这次我们去掉了Sex的set访问器。96 /// 由于通过构造器已经设置了 Sex属性，所以无需通过set访问器来设置该属性97 /// 按照一般情况，Sex属性在对象实例化后，不应该设置该属性。98 /// 属性可以只具有set访问器或get访问器，即 “只读”或“只写”的属性99 /// </summary>100 public bool Sex {101 get {102 return sex;103 }104 }105 106 /// <summary>107 /// 显示个人信息的方法108 /// </summary>109 public void ShowMe() {110 Console.WriteLine("姓名：{0}，性别：{1}，年龄：{2}岁。", this.Name, this.Sex, this.Age);111 }112 }113 114 class Program {115 static void Main(string[] args) {116 117 // 删除掉public Person()构造器，查看程序编译情况118 // 删除掉所有的构造器，查看程序编译情况119 Person person = new Person();120 person.ShowMe();121 122 // person.Sex = true; // 只读属性禁止了给属性设置值123 124 person = new Person(false);125 person.ShowMe();126 127 person = new Person(18, true);128 person.ShowMe();129 130 person = new Person("小丽", 23, false);131 person.ShowMe();132 }133 }134 }

我们给Person类增加了若干个“构造器”，并修改Sex属性为只读，从而让Person类更更符合客观实际。

对于任何一个类，可以不人为提供构造器，此时编译器会赋予类一个“默认构造器”，即没有参数的构造器。这个构造器什么也不做，仅仅是为了new操作 符能够得以指定一个构造器。

而我们一旦定义了有参数的构造器，编译器便会这样认为“这个类的对象必须提供参数才能够实例化”，便不再会提供无参数的默认构造器了。所以一个类如 果同时需要有默认构造器和有参数的构造器，则默认构造器必须手动提供，不要指望编译器会自动生成。

现在我们可以完整定义new操作符的语法规范：类名 变量名 = new 类构造器名(构造器实参数列表）;


C#语言 第一部分 面向对象 （四） 字段默认值

C# 中，可以给类字段以一个默认值，这样一方面可以简化构造器的代码，另一方面较为直观，是一种推荐的方式。

这一章比较简单，可结合上一章深入理解构造器的作用。

看代码：
1 using System;2 using System.Collections.Generic;3 using System.Linq;4 using System.Text;5 6 namespace Edu.Study.OO.DefaultValue {7 8 /// <summary>9 /// 还是那个人类。10 /// 通过构造器11 /// </summary>12 public class Person {13 14 /// <summary>15 /// 保存名字的字段，默认值为 小王16 /// </summary>17 private string name = "小王";18 19 /// <summary>20 /// 保存年龄的字段，默认值为2221 /// </summary>22 private int age = 22;23 24 /// <summary>25 /// 保存性别的字段，true为男性，false为女性，默认值为女性26 /// </summary>27 private bool sex = false;28 29 /// <summary>30 /// 默认构造器，由于字段定义了默认值，所以构造器中无需给字段赋值31 /// </summary>32 public Person() {33 }34 35 /// <summary>36 /// 带有参数的构造器，这里的构造器给所有字段都赋了值，所以无视默认值37 /// </summary>38 public Person(string name, int age, bool sex) {39 this.Name = name;40 this.Age = age;41 this.sex = sex;42 }43 44 /// <summary>45 /// 带有部分参数的构造器，这里只给sex和age字段赋值，而name字段本身就有默认值46 /// </summary>47 public Person(int age, bool sex) {48 this.Age = age;49 this.sex = sex; // 这里，Sex属性50 }51 52 /// <summary>53 /// 带有部分参数的构造器，这里只给sex字段赋值，其它字段都有默认值54 /// </summary>55 public Person(bool sex) {56 this.sex = sex;57 }58 59 /// <summary>60 /// 姓名属性61 /// </summary>62 public string Name {63 get {64 // get访问器必须返回一个值，作为该属性的“属性值65 return this.name;66 }67 set {68 // set访问器具有一个局部变量value，该值是从外部设置给该属性的值69 this.name = value;70 }71 }72 73 /// <summary>74 /// 年龄属性75 /// </summary>76 public int Age {77 get {78 return age;79 }80 set {81 age = value;82 }83 }84 85 /// <summary>86 /// 性别属性，这次我们去掉了Sex的set访问器。87 /// 由于通过构造器已经设置了Sex属性，所以无需通过set访问器来设置该属性88 /// 按照一般情况，Sex属性在对象实例化后，不应该设置该属性。89 /// 属性可以只具有set访问器或get访问器，即“只读”或“只写”的属性90 /// </summary>91 public bool Sex {92 get {93 return sex;94 }95 }96 97 /// <summary>98 /// 显示个人信息的方法99 /// </summary>100 public void ShowMe() {101 Console.WriteLine("姓名：{0}，性别：{1}，年龄：{2}岁。", this.Name, this.Sex, this.Age);102 }103 }104 105 class Program {106 static void Main(string[] args) {107 108 // 删除掉public Person()构造器，查看程序编译情况109 // 删除掉所有的构造器，查看程序编译情况110 Person person = new Person();111 person.ShowMe();112 113 // person.Sex = true; // 只读属性禁止了给属性设置值114 115 person = new Person(false);116 person.ShowMe();117 118 person = new Person(18, true);119 person.ShowMe();120 121 person = new Person("小丽", 23, false);122 person.ShowMe();123 }124 }125 }

在声明字段的同时，可以用赋值运算符（=）在字段后面直接加上一个值（例如第17行），但这和给变量赋值是两个概念。

以赋值运算符跟随在字段之后的值称为字段的“默认值”。这只是一种形式，并不是写在这里就在这里发生赋值，真正 发生赋值的时机还是在构造器中，只不过……

无论我们通过哪个构造器创建类的对象实例，这个构造器中，没有显式赋值的字段，都会由编译器增加一句赋值代码，将该字段赋值为设定 的默认值。

其实，无论我们是否给字段增加了默认值，字段都具备默认值的，只不过如果我们没有人为增加默认值，字段的默认值将是0或null。

C#语言 第一部分 面向对象 （五） 继承

在现实生活中，类和类之间可能会有一种这样的关系：一个类是另一个类的扩展，反过来讲，后一个类是前一个类的基础。

例如：动物类是猫类的基础，猫类是动物类的扩展。这种关系称为继承，即猫类继承了动物类。

被继承的类称为父类（C++说法），基类（C#说法）或超类（Java说法），另一个类叫做子类。怎么叫无所谓，关键看效果。

所谓扩展，就是子类拥有超类的一切特征（包括属性和方法），而子类还可以在超类的基础上添加自身的属性和方法。例如：猫类拥有动物类的一切属性和行 为，但猫类还具有自身的属性（例如长胡子，喵喵叫）和行为（例如磨爪子，抓耗子）。

子类虽然拥有超类的一切特征，但并不是说子类可以任意的去访问继承下来的这些超类特征，子类只能访问到超类中访问修饰符为 public或proctected的那部分属性和方法，其余的属性和方法无法直接访问。

C#的这种继承成为无条件继承，即子类必须继承超类的所有特性，无法选择。

看代码：
1 using System;2 3 namespace Edu.Study.OO.Inherit {4 5 /// <summary>6 /// 依旧是人类7 /// </summary>8 public class Person {9 10 /// <summary>11 /// 保存名字的字段12 /// 访问修饰符protected表示被修饰的成员不仅可以被当前类访问，还可以被该类的所有子类访问，但不能通过对象被其它类访问。13 /// </summary>14 protected string name;15 16 /// <summary>17 /// 保存年龄的字段18 /// </summary>19 protected int age;20 21 /// <summary>22 /// 保存性别的字段23 /// </summary>24 protected bool sex;25 26 /// <summary>27 /// 带有参数的构造器28 /// </summary>29 public Person(string name, int age, bool sex) {30 this.Name = name;31 this.Age = age;32 this.sex = sex;33 }34 35 /// <summary>36 /// 姓名属性37 /// </summary>38 public string Name {39 get {40 return this.name;41 }42 set {43 this.name = value;44 }45 }46 47 /// <summary>48 /// 年龄属性49 /// </summary>50 public int Age {51 get {52 return age;53 }54 set {55 age = value;56 }57 }58 59 /// <summary>60 /// 性别属性61 /// </summary>62 public bool Sex {63 get {64 return sex;65 }66 set {67 sex = value;68 }69 }70 71 /// <summary>72 /// 显示个人信息的方法73 /// </summary>74 public void ShowMe() {75 Console.WriteLine("姓名：{0}，性别：{1}，年龄：{2}岁。", this.Name, this.Sex, this.Age);76 }77 }78 79 /// <summary>80 /// 男人类，从Person类继承81 /// </summary>82 public class Man : Person {83 84 /// <summary>85 /// 构造器。86 /// 如果超类没有提供无参数的默认构造器，则子类就必须具备构造器87 /// 子类的构造器参数没有必要和超类相同，但子类构造器必须使用base关键字调用超类的某个构造器88 /// </summary>89 public Man(string name, int age)90 : base(name, age, true) {91 }92 93 /// <summary>94 /// 表示男人抽烟的方法95 /// </summary>96 public void Smork() {97 Console.WriteLine("{0}抽了一根烟", base.Name);98 }99 }100 101 /// <summary>102 /// 女人类，从Person类继承103 /// </summary>104 public class Woman : Person {105 106 /// <summary>107 /// 构造器108 /// </summary>109 public Woman(string name, int age)110 : base(name, age, false) {111 }112 113 /// <summary>114 /// 表示女人化妆的方法115 /// </summary>116 public void Makeup() {117 Console.WriteLine("{0}化妆完毕", base.Name);118 }119 }120 121 class Program {122 static void Main(string[] args) {123 Man man = new Man("小张", 19);124 // 调用Man类从Person类继承的方法125 man.ShowMe();126 // 调用Man类自身具有的方法127 man.Smork();128 129 Woman woman = new Woman("小白", 20);130 // 调用Woman类从Person类继承的方法131 woman.ShowMe();132 // 调用Woman类自身具有的方法133 woman.Makeup();134 }135 }136 }

继承最直接的好处是：再设计类的时候，如果存在继承关系，则可以通过继承省略大量代码的书写。

继承可以将类组成宗系，更符合软件开发的思想：组织功能模块（超类），细化功能（子类），功能异化（子类）。这句话可能暂时不好理解，随着对面向对 象学习的深入，慢慢去理解这句话的含义。看看在软件开发中，如何定义一个基本功能类，然后不断的继承它，完成功能的细化和扩展。

对于继承，语法上没有任何难点，关键要理解子类的构造器。

子类必须要调用超类的某个构造器，缺省情况下，子类调用超类的无参默认构造器，但如果超类中没有默认构造器，则必须显式说明，子类 要调用超类的哪个构造器。参考89、90行代码。所谓缺省情况，指的是无需使用base关键字显式调用超类构造器，此时子类自动调用超 类中没有参数的那个构造器。
C#语言 第一部分 面向对象 （六） 变量对对象的引用

很容易理解的概念，直接看代码，不多说了。
1 using System;2 using System.Collections.Generic;3 using System.Linq;4 using System.Text;5 6 namespace Edu.Study.OO.ReferenceRelationship {7 8 /// <summary>9 /// 依旧是人类10 /// </summary>11 public class Person {12 13 /// <summary>14 /// 保存名字的字段15 /// </summary>16 protected string name;17 18 /// <summary>19 /// 保存年龄的字段20 /// </summary>21 protected int age;22 23 /// <summary>24 /// 保存性别的字段25 /// </summary>26 protected bool sex;27 28 /// <summary>29 /// 带有参数的构造器30 /// </summary>31 public Person(string name, int age, bool sex) {32 this.Name = name;33 this.Age = age;34 this.sex = sex;35 }36 37 /// <summary>38 /// 姓名属性39 /// </summary>40 public string Name {41 get {42 return this.name;43 }44 set {45 this.name = value;46 }47 }48 49 /// <summary>50 /// 年龄属性51 /// </summary>52 public int Age {53 get {54 return age;55 }56 set {57 age = value;58 }59 }60 61 /// <summary>62 /// 性别属性63 /// </summary>64 public bool Sex {65 get {66 return sex;67 }68 set {69 sex = value;70 }71 }72 73 /// <summary>74 /// 显示个人信息的方法75 /// </summary>76 public void ShowMe() {77 Console.WriteLine("姓名：{0}，性别：{1}，年龄：{2}岁。", this.Name, this.Sex, this.Age);78 }79 }80 81 /// <summary>82 /// 男人类，从Person类继承83 /// </summary>84 public class Man : Person {85 86 /// <summary>87 /// 构造器。88 /// </summary>89 public Man(string name, int age)90 : base(name, age, true) {91 }92 93 /// <summary>94 /// 表示男人抽烟的方法95 /// </summary>96 public void Smork() {97 Console.WriteLine("{0}抽了一根烟", base.Name);98 }99 }100 101 class Program {102 static void Main(string[] args) {103 Man man = new Man("小王", 22);104 man.ShowMe();105 man.Smork();106 107 Person person = man;108 // 通过ShowMe执行结果可以看 到，person变量实际上就是前面实例化的Man类对象109 // 从这个结果我们可以看出，无论是前面的man 变量，还是person变量，保存的都是一个实际对象的引用，对象客观存在，变量只是给这个对110 // 象赋予的一个代称，一个对象可以拥有多个代 称，即一个对象可以被多个变量引用，例如：111 // Man man2 = man;112 // 此时，定义的新变量man2, 它和man变量具有相同的引用113 person.ShowMe();114 115 // Person person = man这句代码表达了一个很容易理解的说法，男 人是人。116 // 这种说法隐含了这样的含义：使用超类定义的变 量可以“引用”到某一个子类实例化的对象上117 // 反过来呢？人是男人？这种说法显然是不通的， 除非我们确定我们所说得人确实是一个男人，所以118 man = (Man)person;119 // 这里我们应用了C语言风格的类型转换运算，由 于事先已经知道person变量确确实实是引用到Man类对象的变量，所以120 // 可以将其转换为Man类的变量121 122 // person.Smork();123 // 试着将上面这句话的注释删掉，这时候会发生一 个编译错误。Smork方法无效。这里注意，虽然我们确定person变量124 // 引用着Man类的对象，但person变量的 类型依旧是Person类，而Person类是没有smork方法的125 126 }127 }128 }

只要能够理解变量保存的是一个“对象的引用”，就可以理解上面代码的含义了。
C#语言 第一部分 面向对象 （七） 方法重载

一只狼狗无忧无虑的走在大街上，狼狗天性好斗，所以应该有一个Fight方法。

这时候他碰到了一只小狗，即Puppy类的一个对象，此时狼狗调用Fight方法，将这只puppy作为参数传入，将其狠狠修理了一顿。

不一会儿，它又碰到一只大狗，很凶恶的样子，此时狼狗的心里没有必胜的把握，但它依旧调用了Fight方法，将大狗作为参数传入。不过这 次，Fight方法只是示威了一下而已，叫了几声，然后就结束了。

又过了一会儿，它碰到了一大群狗，即一个狗数组，此时狼狗吓得屁滚尿流，但还是调用了Fight方法，将狗数组作为参数传入。这次，Fight方法 执行的结果，狼狗逃之夭夭了。

可见，在我们现实生活中，总是存在这样一种情况：某类对象的某种行为，因为外界条件不同（参数不同），执行的具体流程也不同。体现在编程代码中，就 是方法的重载。

在同一个类（或某个类和它的子类）中，一系列同名的方法就构成了“重载”，重载的条件是：方法名相同，参数列表不同。 对于子类要重载超类方法的情况，超类该方法必须为protected或public类型。

看代码：
1 using System;2 3 namespace Edu.Study.OO.Overload {4 5 /// <summary>6 /// 继续人类7 /// </summary>8 public class Person {9 10 /// <summary>11 /// 保存名字的字段12 /// </summary>13 protected string name;14 15 /// <summary>16 /// 保存年龄的字段17 /// </summary>18 protected int age;19 20 /// <summary>21 /// 保存性别的字段22 /// </summary>23 protected bool sex;24 25 /// <summary>26 /// 带有参数的构造器27 /// </summary>28 public Person(string name, int age, bool sex) {29 this.Name = name;30 this.Age = age;31 this.sex = sex;32 }33 34 /// <summary>35 /// 姓名属性36 /// </summary>37 public string Name {38 get {39 return this.name;40 }41 set {42 this.name = value;43 }44 }45 46 /// <summary>47 /// 年龄属性48 /// </summary>49 public int Age {50 get {51 return age;52 }53 set {54 age = value;55 }56 }57 58 /// <summary>59 /// 性别属性60 /// </summary>61 public bool Sex {62 get {63 return sex;64 }65 set {66 sex = value;67 }68 }69 70 /// <summary>71 /// 显示个人信息的方法72 /// </summary>73 public void ShowMe() {74 Console.WriteLine("姓名：{0}，性别：{1}，年龄：{2}岁。", this.Name, this.Sex, this.Age);75 }76 }77 78 /// <summary>79 /// 男人类80 /// </summary>81 public class Man : Person {82 83 /// <summary>84 /// 构造器。85 /// </summary>86 public Man(string name, int age)87 : base(name, age, true) {88 }89 90 /// <summary>91 /// 表示男人抽烟的方法92 /// </summary>93 public void Smork() {94 Console.WriteLine("{0}抽了一根烟", base.Name);95 }96 }97 98 /// <summary>99 /// 女人类，从Person类继承100 /// </summary>101 public class Woman : Person {102 103 /// <summary>104 /// 构造器105 /// </summary>106 public Woman(string name, int age)107 : base(name, age, false) {108 }109 110 /// <summary>111 /// 表示女人化妆的方法112 /// </summary>113 public void Makeup() {114 Console.WriteLine("{0}化妆完毕", base.Name);115 }116 }117 118 /// <summary>119 /// 厕所类120 /// </summary>121 public class Toilet {122 123 /// <summary>124 /// 厕所进入方法，参数为Man类型125 /// </summary>126 public void Comming(Man man) {127 Console.WriteLine("{0}进了男厕所", man.Name);128 man.Smork();129 }130 131 /// <summary>132 /// 厕所进入方法，参数为Woman类型133 /// </summary>134 public void Comming(Woman women) {135 Console.WriteLine("{0}进了女厕所", women.Name);136 women.Makeup();137 }138 }139 140 class Program {141 static void Main(string[] args) {142 143 // 实例化厕所对象144 Toilet wc = new Toilet();145 146 // 实例化一个男人和一个女人147 Man wang = new Man("小王", 22);148 Woman li = new Woman("小丽", 19);149 150 // 调用厕所类的Comming方法，分别传入 Man类型变量和Woman类型变量151 wc.Comming(wang);152 wc.Comming(li);153 154 // 可以发现，通过方法的参数，C#编译器会自动 匹配最合适的方法进行调用。155 // 方法重载可以使用同一个方法名，对传入不同参 数的各种调用场景进行自动适应156 // 重载的要点：方法名相同，参数列表不同157 }158 }159 }

熟练应用重载，虽然它并不能直接简化类的编程，但对于调用这个类的程序开发人员来说，重载则更好理解，也更直观。

前面我们讲过，只要参数列表不同，一个类可以拥有多个构造器。构造器的本质还是方法，所以多个构造器实际上还是构成了方法的重载。
C#语言 第一部分 面向对象 （九） 方法的抽象和类的抽象 练习

上一章我们讲了方法和类的抽象，这一章我们从一些例子，继续加深对抽象的理解。

第一个例子，我们定义了形状类（Shap类），从类名字就可以看出该类必然是一个抽象类。形状……本来就很抽象嘛。

好了，既然是形状，就必然有面积，Shap类的Area方法必然是一个抽象方法。

接下来，我们创建一个子类：正多边形类（Polygon类），继承自Shap类。这个类比形状类具体多了，我们知道了一个新的属性：边长。但只知道 边长依旧无法求出形状的面积，所以其继承下来的Area方法依旧只能作为抽象方法，所以Polygon类仍是一个抽象类。

最后，定义正四边形类和正五边形类，这两个类显然非常具体了，可以定义Area方法了。就这样，看代码：
1 using System;2 using System.Collections.Generic;3 using System.Linq;4 using System.Text;5 6 namespace Edu.Study.OO.UseAbstract {7 8 /// <summary>9 /// 定义形状类10 /// </summary>11 public abstract class Shap {12 /// <summary>13 /// 定义抽象方法，求面积，对于形状类，面积方法没有方法体14 /// </summary>15 /// <returns>面积</returns>16 public abstract double Area();17 }18 19 /// <summary>20 /// 定义多边形类，此类继承了Area方法，但并未实现，所以依旧是抽象类21 /// </summary>22 public abstract class Polygon : Shap {23 24 /// <summary>25 /// 边长字段26 /// </summary>27 private double sideLength;28 29 /// <summary>30 /// 构造器，输入边长31 /// </summary>32 public Polygon(double sideLength) {33 this.SideLength = sideLength;34 }35 36 /// <summary>37 /// 边长属性38 /// </summary>39 public double SideLength {40 get {41 return sideLength;42 }43 set {44 if (value > 0) {45 sideLength = value;46 } else {47 Console.WriteLine("边长必须大于0。");48 }49 }50 }51 }52 53 /// <summary>54 /// 定义正方形类，继承自多边形类（Polygon类）55 /// </summary>56 public class Square : Polygon {57 58 /// <summary>59 /// 构造器60 /// </summary>61 public Square(double sideLength)62 : base(sideLength) {63 }64 65 /// <summary>66 /// 求正方形面积，实现超类的抽象方法67 /// </summary>68 public override double Area() {69 return Math.Pow(this.SideLength, 2);70 }71 }72 73 /// <summary>74 /// 定义五边形类75 /// </summary>76 public class Pentagon : Polygon {77 78 /// <summary>79 /// 构造器80 /// </summary>81 public Pentagon(double sideLength)82 : base(sideLength) {83 }84 85 /// <summary>86 /// 求五边形面积，这里使用工程计算求近似值，即边长的平方乘以系数1.7287 /// </summary>88 public override double Area() {89 return Math.Pow(this.SideLength, 2) * 1.72F;90 }91 }92 93 class Program {94 95 static void Main(string[] args) {96 97 // 使用Shap类变量引用到Square类实例 上98 Shap shap = new Square(10);99 // 输出面积结果100 Console.WriteLine("面积={0}", shap.Area());101 102 // 使用Shap类变量引用到Pentagon类 实例上103 shap = new Pentagon(10);104 // 输出面积结果105 Console.WriteLine("面积={0}", shap.Area());106 }107 }108 } 
我们继续，下面的例子展示了抽象的属性，我们说过，一个对象的属性由一组get/set方法来表现，所以属性也可以作为抽象存在。

下面的例子我们定义了Person类，其EyeColor属性为一个抽象属性，由其子类来具体定义。看代码：
1 using System;2 using System.Collections.Generic;3 using System.Linq;4 using System.Text;5 6 namespace Edu.Study.OO.UseAbstact2 {7 8 /// <summary>9 /// 又见人类10 /// </summary>11 public abstract class Person {12 /// <summary>13 /// 人名字字段14 /// </summary>15 private string name;16 17 /// <summary>18 /// 构造器，输入人名19 /// </summary>20 public Person(string name) {21 this.Name = name;22 }23 24 /// <summary>25 /// 人名属性26 /// </summary>27 public string Name {28 get {29 return name;30 }31 set {32 name = value;33 }34 }35 36 /// <summary>37 /// 定义一个抽象属性，指明这个属性必须具备get/set访问器，都是抽象的38 /// 这里为了明确，所以为该属性定义了set访问器，其实也不是没有道理，戴个隐形眼镜就可以改变眼睛的颜色了39 /// 当然，也可以只定义某一个访问器，形成抽象只读属性或抽象只写属性40 /// </summary>41 public abstract string EyeColor {42 get;43 set;44 }45 }46 47 48 /// <summary>49 /// 定义亚洲人类，继承自人类50 /// </summary>51 public class AsiaPerson : Person {52 53 /// <summary>54 /// 隐形眼镜颜色字段55 /// </summary>56 private string lensesColor;57 58 /// <summary>59 /// 构造器，调用超类构造器60 /// </summary>61 public AsiaPerson(string name)62 : base(name) {63 }64 65 /// <summary>66 /// 眼睛颜色属性，实现超类抽象属性67 /// </summary>68 public override string EyeColor {69 get {70 // 如果戴隐形眼镜，则返回隐形眼镜的颜色，否则返回黑色71 if (this.lensesColor != null) {72 return this.lensesColor;73 } else {74 return "Black";75 }76 }77 set {78 // 无法设置眼睛的颜色，所以给隐形眼镜加上颜色79 this.lensesColor = value;80 }81 }82 }83 84 /// <summary>85 /// 欧洲人类86 /// </summary>87 public class EuropePerson : Person {88 89 /// <summary>90 /// 隐形眼镜颜色字段91 /// </summary>92 private string lensesColor;93 94 /// <summary>95 /// 构造器，调用超类构造器96 /// </summary>97 public EuropePerson(string name)98 : base(name) {99 }100 101 /// <summary>102 /// 眼睛颜色属性，实现超类抽象属性103 /// </summary>104 public override string EyeColor {105 get {106 // 如果戴隐形眼镜，则返回隐形眼镜的颜色，否则返回蓝色107 if (this.lensesColor != null) {108 return this.lensesColor;109 } else {110 return "Blue";111 }112 }113 set {114 // 无法设置眼睛的颜色，所以给隐形眼镜加上颜色115 this.lensesColor = value;116 }117 }118 }119 120 class Program {121 static void Main(string[] args) {122 Person person = new AsiaPerson("王毛毛");123 Console.WriteLine("{0}眼睛颜色为：{1}", person.Name, person.EyeColor);124 person.EyeColor = "Brown";125 Console.WriteLine("{0}眼睛颜色为：{1}", person.Name, person.EyeColor);126 127 person = new EuropePerson("Wang Maomao");128 Console.WriteLine("{0}眼睛颜色为：{1}", person.Name, person.EyeColor);129 person.EyeColor = "Green";130 Console.WriteLine("{0}眼睛颜色为：{1}", person.Name, person.EyeColor);131 }132 }133 }
Technorati 标签: C#,教学

另外，我们也可以单独定义get或set访问器中的一个为抽象。这里就不做展示了。
C#语言 第一部分 面向对象 （十） 方法的隐藏

我们前面讲过了类和类之间的继承关系，我们了解到，超类方法和子类方法（或属性）可以具备三种联系方式。

    * 继承。超类修饰为public或protected的方法或属性可以被子类继承并访问；
    * 虚拟。虚拟的前提是可继承。超类中修饰为virtual关键字的方法或属性可以被子类继承或覆盖；
    * 抽象。抽象的前提是可继承。超类中修饰为abstract关键字的方法或属性可以被子类继承并实现，超类方法 没有方法体，由子类提供；

现在我们来学习超类方法（或属性）和子类方法（或属性）的第四种联系——隐藏。

子类继承超类方法，并一个和该方法同名、同参数的新方法，子类方法前不使用override关键字修饰。这种情况子类隐藏了超类继承的一个方法。

隐藏和覆盖最大的不同：隐藏的方法只能用该方法所属的类的变量访问，使用超类变量则无法访问，只能访问被隐藏的方法。看例子：
1 using System;2 using System.Collections.Generic;3 using System.Linq;4 using System.Text;5 6 namespace Edu.Study.OO.Hiden {7 8 /// <summary>9 /// 定义一个球体类10 /// </summary>11 public class Ball {12 13 /// <summary>14 /// 半径字段15 /// </summary>16 private double r;17 18 /// <summary>19 /// 构造器，输入球体半径20 /// </summary>21 public Ball(double r) {22 this.R = r;23 }24 25 /// <summary>26 /// 半径属性27 /// </summary>28 public double R {29 get {30 return this.r;31 }32 set {33 if (value > 0) {34 this.r = value;35 } else {36 Console.WriteLine("半径长度必须大于0。");37 }38 }39 }40 41 /// <summary>42 /// 球体面积方法，返回球体面积，该方法虚拟43 /// </summary>44 public virtual double Area() {45 return 4 * Math.PI * Math.Pow(this.R, 2);46 }47 48 /// <summary>49 /// 球体体积方法，返回球体体积，该方法虚拟50 /// </summary>51 public virtual double Volume() {52 return (4F / 3F) * Math.PI * Math.Pow(this.R, 3);53 }54 }55 56 57 /// <summary>58 /// 圆柱体类，继承自球体59 /// </summary>60 public class Cylindrical : Ball {61 62 /// <summary>63 /// 圆柱体高度64 /// </summary>65 private double height;66 67 /// <summary>68 /// 构造器，输入半径和高度69 /// </summary>70 public Cylindrical(double r, double height)71 : base(r) {72 this.Height = height;73 }74 75 /// <summary>76 /// 高度属性77 /// </summary>78 public double Height {79 get {80 return this.height;81 }82 set {83 if (value > 0) {84 this.height = value;85 } else {86 Console.WriteLine("高度必须大于0。");87 }88 }89 }90 91 /// <summary>92 /// 覆盖超类中虚拟的面积方法，求圆柱体表面积93 /// </summary>94 public override double Area() {95 return (2 * Math.PI * this.R * this.Height) + (Math.PI * Math.Pow(this.R, 2) * 2);96 }97 98 /// <summary>99 /// 隐藏超类中球体积的方法，改为求圆柱体体积100 /// </summary>101 public new double Volume() {102 return Math.PI * Math.Pow(this.R, 2) * this.Height;103 }104 }105 106 class Program {107 108 static void Main(string[] args) {109 110 // 输出Ball类对象Area方法和 Volume方法的返回值111 Ball ball = new Ball(20);112 Console.WriteLine("Ball's area = {0}", ball.Area());113 Console.WriteLine("Ball's area = {0}", ball.Volume());114 115 // 输出Cylindrical类对象Area方 法和Volume方法的返回值116 Cylindrical cyl = new Cylindrical(20, 30);117 Console.WriteLine("Cylindrical's area = {0}", cyl.Area());118 Console.WriteLine("Cylindrical's area = {0}", cyl.Volume());119 120 121 // 令Ball类的变量引用到 Cylindrical类的对象上122 ball = cyl;123 Console.WriteLine("Ball's area = {0}", ball.Area()); // 此处调用Area方法时，调用的其实是Cylindrical类的Area方法124 Console.WriteLine("Ball's area = {0}", ball.Volume()); // 此处调用Volume方法时，调用的其实是Ball类的方法125 }126 }127 }

从代码中可以清楚的看到覆盖和隐藏具体的区别，当使用超类变量引用到子类实例后，依旧可以访问子类覆盖后的方法，但无法访问到子类隐藏后的方法，只 能访问被子类隐藏的方法。

注意，本例是为了让大家看明白覆盖和隐藏的区别，对于隐藏来说，被隐藏的超类方法无须修饰为virtual。

一半，子类方法要隐藏父类方法，在方法声明前加上new关键字，表示此方法是被隐藏的方法。new关键字并不是必需的。

隐藏表示了这样一种含义：子类定义了和超类名称相同但流程不同的方法，但只能以子类类型可以访问，使用超类类型则无法访问。

隐藏的情况较之覆盖要少见一些，以至于许多面向对象语言（例如Java）并不提供方法的隐藏。C#提供此特性是为了保证语言的完整性，在一些特殊情 况下可以解决一些问题。
C#语言 第一部分 面向对象 （十一） 接口

学习过C++的童鞋都应该知道，在C++中允许将一个类的成员函数定义为virtual（虚拟函数），定义为虚拟的函数，例如：
1 class CTest2 {3 public:4 virtual void TestA();5 virtual void TestB() = 0;6 };7 8 void CTest::TestA()9 {10 cout<<"Hello"<<endl;11 }12 13 class CTestChild : public CTest14 {15 public:16 virtual void TestB();17 };18 19 void CTestChild::TestB()20 {21 cout<<"Hello World"<<endl;22 }23 24 int main(int argc, char* argv[])25 {26 CTest* pTest = new CTestChild();27 pTest->TestA();28 pTest->TestB();29 }

形如第4行的函数声明称为“虚拟函数”，可以被子类的同名函数（返回值类型，参数也必须完全相同）覆盖；形如第 5行的函数声明称为“纯虚拟函数”，这个函数没有函数体，必须被子类的同名函数（返回值类型，参数也必须完全相同）覆盖。

前面的课程，我们学习了C#中的虚拟方法（使用virtual修饰的方法）和抽象方法（使用abstract修饰的方法），相当于C++中的虚拟函数和纯虚拟函数。

我们可以在C++中设计这样的一种类，这个类中的所有成员函数都为纯虚拟函数，即都没有方法体。这种类型的类非常有用。在C#中，语言设计者为它起了一个新的名字——接口。

接口是那样的有用，以至于成为了一个程序员是否完全理解面向对象的重要标志。

接口在现实生活中非常常见，例如我们连接DVD影碟机和电视机，只要我们有这样的两个设备，使用电缆将它们连接在一起就可以了，无须考虑这两个设备是否可以相互兼容。这其中的道理非常简单，影碟机可以输出AV信号，电视机可以接受AV信号，所以可以连接。

电脑主机箱和显示器的道理也是如此；U盘和USB接口的道理也相同。

所以接口并不是一个实际存在的插口，而是双方都共同遵守的一种行为准则。因为双方都遵守这样的规范，所以双方可以毫无障碍的联系在一起。

什么叫做行为准则？例如我定义一个行为准则叫做Eatable（可食用的），凡是遵守这个准则的对象，就都可以塞进嘴巴里并咽下去，就像超市卖的食品上面蓝色的S标志，当得知对象遵循这个准则，则无需关心这个对象的成分、形状或任何其它属性，就可以把它和我们的嘴巴联系起来（当然营养与否，好吃不好吃那是另一码事儿了）。

聪明的童鞋可能已经反应过来了，所谓行为规范，就是不同对象所属的不同类，具有相同的超类，并且都实现了超类中定义的抽象方法。这样所有的类就具备相同的行为规范了。这种想法，在C++中是可行的。但在C#中，对于接口的定义则更为严格，原因有二：

   1. C#并不允许多继承，而C++可以，C#不想出现C++中难以理解的父子悖论而禁止多继承，所以在C#中，一旦使用超类来约束行为，则会对编程带来不小的麻烦——我们没法再继承其它类或引入其它行为准则了。
   2. 符合同一行为准则的，可以是完全不相干的不同类，例如同样符合 Eatable可食用准则的类，有可能是化学品类的子类，也有可能是生物类的子类或者植物种子类的子类。使用超类引入行为准则从继承的角度是非常不合理的。

我们来看一个例子：
1 public abstract class Runnable {2 public abstract void Run();3 }4 5 public class Mechanical{6 }7 8 public class Car : Mechanical{9 }10 11 public class Animal {12 }13 14 public class Cat : Animal {15 }

代码中，我试图确立一种行为规范称之为“会跑的”（Runnable），有两个类需要遵循此规范，Car类和Cat类，显然汽车和猫都是会跑的东西，都可以实现抽象方法Run。

但问题出现了，Car类显然需要从机械类（Mechanical）继承，因为汽车是机械的一种，但显然并不是所有的机械都会跑（例如电动刮胡刀）；而Cat类显然是从动物类（Animal）继承，但也不是所有的动物都会跑（例如鱼）。Car和Cat完全找不到相同的超类，但它们又可以遵循同样的行为规范，一个类不可能既继承自Animal类又继承自Runnable类！怎么办？

再看代码：
1 public interface Runnable {2 void Run();3 }4 5 public class Mechanical {6 }7 8 public class Car : Mechanical, Runnable {9 public void Run() {10 Console.WriteLine("汽车开走了！");11 }12 }13 14 public class Animal {15 }16 17 public class Cat : Animal, Runnable {18 public void Run() {19 Console.WriteLine("猫跑掉了！");20 }21 }

我们使用了一个新的关键字interface，很容易就解决了上面的问题，用interface声明的我们称为接口。我们发现，接口中可以包含方法的声明，而所有的类除了可以继承一个超类外，还可以继承多个接口。当然，习惯上把对接口的继承不叫做继承，而叫做“实现”，即一个类实现了某些接口。

接口定义的特点：接口中定义的方法上，自动为public abstract，即公共抽象方法。接口本身也为抽象。接口中不允许以任何方式包含具有方法体的方法。

接口完美的解决了所有的问题：

    * 接口中只允许包含方法声明，所以即便接口被多继承，也不会产生任何父子悖论问题；
    * 接口不是实体类，不带有类别的含义，只是一种行为的规范，所以可以被不同含义的多个类同时继承；
    * 接口可以赋予不同的类相同的行为准则（接口中定义的方法声明），所以接口类型变量可以引用到所有实现此接口类的实例上。

属性是一对方法，所以接口中也可以包含属性的定义。接口中不允许出现字段的定义。
1 public interface Runnable {2 // 定义抽象属性3 double Speed {4 get;5 }6 void Run();7 }8 9 public class Mechanical {10 }11 12 public class Car : Mechanical, Runnable {13 private double speed = 60.0;14 15 public void Run() {16 Console.WriteLine("汽车开走了！");17 }18 19 /// <summary>20 /// 实现接口中定义的抽象属性并添加 set访问器21 /// </summary>22 public double Speed {23 get {24 return this.speed;25 }26 set {27 this.speed = value;28 }29 }30 }31 32 public class Animal {33 }34 35 public class Cat : Animal, Runnable {36 37 public void Run() {38 Console.WriteLine("猫跑掉了！");39 }40 41 /// <summary>42 /// 实现接口中定义的抽象属性43 /// </summary>44 public double Speed {45 get {46 return 5.0;47 }48 }49 }

好了，我们看一段完整的代码，从中体会接口的特点。
1 using System;2 3 namespace Edu.Study.OO.Interface {4 5 public interface Runnable {6 // 定义抽象属性，该属性只读7 double Speed {8 get;9 }10 void Run();11 }12 13 /// <summary>14 /// 定义机械类，为了简便此类没有定义属性和方法15 /// </summary>16 public class Mechanical {17 }18 19 /// <summary>20 /// 定义汽车类，从机械类继承，实现Runnable接口21 /// </summary>22 public class Car : Mechanical, Runnable {23 24 /// <summary>25 /// 保存速度属性值的字段26 /// </summary>27 private double speed = 60.0;28 29 /// <summary>30 /// 实现接口定义的Run方法31 /// </summary>32 public void Run() {33 Console.WriteLine("汽车开走了！");34 }35 36 /// <summary>37 /// 实现接口中定义的抽象属性并添加set访问器38 /// </summary>39 public double Speed {40 get {41 return this.speed;42 }43 // 注意：set访问器不是接口所定义44 set {45 this.speed = value;46 }47 }48 }49 50 /// <summary>51 /// 定义动物类，为了简便此类没有定义属性和方法52 /// </summary>53 public class Animal {54 }55 56 /// <summary>57 /// 定义猫类，继承自动物类，实现Runnable接口58 /// </summary>59 public class Cat : Animal, Runnable {60 61 /// <summary>62 /// 实现接口中的Run方法。63 /// </summary>64 public void Run() {65 Console.WriteLine("猫跑掉了！");66 }67 68 /// <summary>69 /// 实现接口中定义的抽象属性70 /// </summary>71 public double Speed {72 get {73 return 5.2;74 }75 }76 }77 78 /// <summary>79 /// 定义道路类80 /// </summary>81 public abstract class Road {82 83 /// <summary>84 /// 定义抽象属性，限速，只读85 /// </summary>86 public abstract double SpeedLimit {87 get;88 }89 90 /// <summary>91 /// 在路上跑的方法，所有可以跑的东西都可以作为参数92 /// </summary>93 public void RunAt(Runnable runner) {94 // 如果传入对象的速度不够，则不运行其Run方法95 if (runner.Speed < this.SpeedLimit) {96 Console.WriteLine("对不起，速度不够，不能在道路上奔跑。");97 } else {98 runner.Run();99 }100 }101 }102 103 /// <summary>104 /// 定义低速路，继承自Road类105 /// </summary>106 public class LowSpeedRoad : Road {107 108 /// <summary>109 /// 覆盖Road类抽象属性110 /// </summary>111 public override double SpeedLimit {112 get {113 return 5;114 }115 }116 }117 118 /// <summary>119 /// 定义高速路，继承自Road类120 /// </summary>121 public class HighSpeedRoad : Road {122 123 /// <summary>124 /// 覆盖Road类抽象属性125 /// </summary>126 public override double SpeedLimit {127 get {128 return 90;129 }130 }131 }132 133 class Program {134 static void Main(string[] args) {135 // 定义一只猫136 Cat cat = new Cat();137 138 // 定义一辆车139 Car car = new Car();140 car.Speed = 100; // 由于car的Speed属性具有set访问器，所以可以设置属性值141 142 // 定义高速路143 Road road = new HighSpeedRoad();144 road.RunAt(cat);145 road.RunAt(car);146 147 // 定义低速路148 road = new LowSpeedRoad();149 road.RunAt(cat);150 }151 }152 }

 

除了上面讲的接口概念，C#还有一个非常有趣的特性，即接口的显式实现，接口显式实现体现了这样一种效果：一个类同时实现多个接口中的多个同名方法。例如接口IA中有个方法void Test();，接口IB也有一个方法void Test();，类C实现IA和IB接口。如下:

1 /// <summary>2 /// 接口IA3 /// </summary>4 public interface IA {5 /// <summary>6 /// 在接口IA中定义Test方法7 /// </summary>8 void Test();9 }10 11 /// <summary>12 /// 接口IB13 /// </summary>14 public interface IB {15 /// <summary>16 /// 在接口IB中定义Test方法(和IA中定义的Test方法一致)17 /// </summary>18 void Test();19 }20 21 /// <summary>22 /// 定义类C，同时实现IA接口和IB接口23 /// 这时候可以有三种选择：24 /// 1、实现IA和IB接口定义的Test方法25 /// 2、针对接口IA实现其定义的Test方法26 /// 3、针对接口IB实现其定义的Test方法27 /// </summary>28 public class C : IA, IB {29 30 /// <summary>31 /// 实现IA和IB接口定义的Test方法32 /// 以public关键字修饰，表示该方法公共33 /// </summary>34 public void Test() {35 Console.WriteLine("OK");36 }37 38 /// <summary>39 /// 指明实现IA接口中定义的Test方法，40 /// 使用 接口名.方法 来指定要实现的方法是由哪一个接口定义的。41 /// 显式实现的方法前无访问修饰符，表示其至少不是public的，所以无法使用C类对象直接访问42 /// </summary>43 void IA.Test() {44 Console.WriteLine("Hello");45 }46 47 /// <summary>48 /// 指明实现IB接口中定义的Test方法49 /// </summary>50 void IB.Test() {51 Console.WriteLine("World");52 }53 }54 55 /// <summary>56 /// 主方法57 /// </summary>58 static void Main(string[] args) {59 60 // 实例化C类的对象61 C c = new C();62 63 // 通过C类对象调用Test方法，这时调用的是以public修饰符修饰的Test实现64 c.Test();65 66 // 将C类的引用类型提升为IA类的引用类型，此时，调用的是C类中显式实现的 IA.Test方法67 IA a = c;68 a.Test();69 70 // 将C类的引用类型提升为IB类的引用类型，此时，调用的是C类中显式实现的 IB.Test方法71 IB b = c;72 b.Test();73 }

所以，接口的显式实现就是一个类可以显式的指定一个方法实现的是哪个接口的方法。显式实现接口的方法前无须添加访问修饰符，使用类的对象也无法直接访问（因为它不是public的），但可以通过将类对象引用类型提升为其接口类型来间接访问该方法。

注意：不到万不得已，无须使用接口的显示实现以尽量减少一个类对接口实现的复杂程度。