知识点：理解多态的概念 、掌握使用虚方法实现多态、 理解抽象类和抽象方法

1、理解多态

提出问题：我们上一课学到的【继承】，知道子类从父类那里继承的方法时完全一致的，如项目实践里，当我们使用不同的游戏道具时，他们都调用了父类的方法，并没有体现出不同游戏道具之间的区别。

解决问题：当子类从父类那里继承某个方法之后，子类对于这个方法有不同的响应方式，成为多态。

1.1  什么是多态

           多态（polymorphism）可以理解为多种形态，自然界的物质都存在多种形态，如水就有液态、固态和气态三种。而面向对象中的多态，主要和对象的操作有关，不同的对象进行同一个操作时，可以有不同的实现方法。举个例子，人类都需要吃东西，而不同国家的人有不同的吃东西方式，中国人用筷子，美国人用刀叉，印度人用手。

通俗理解：通过继承实现的不同对象调用相同的方法，表现出不同的行为，称之为多态。

1.2   实现多态的方式

• 使用虚方法+重写（用的少，C#特有的方式）
• 使用抽象方法+抽象类  重写（用的多 ，共性）
• 使用接口实现 （用的多，面向接口编程）

2、使用虚方法实现多态

虚方法：可以被子类重写的方法，称为虚方法。

使用虚方法，实现多态的实现步骤：

1）将父类中的方法（子类需要重写的方法）使用virtual关键字，定义成虚方法

public virtual 返回值类型 方法名(参数列表)
{//方法体
}

2）在子类中，对父类的方法使用override关键字，进行重写（覆盖+自己的特性）

public override 返回值类型 方法名(参数列表)
{//方法体
}

注意：进行重写时，子类的方法名和参数列表必须和父类方法相同 。

示例练习1：使用虚方法实现多态（模拟不同国家的人吃饭的方式）

第一步，新建项目：①在VS中新建控制台应用（.NET Framework），这里默认命名为【ConsoleApp6】，单击【确定】按钮，自动完成创建，并打开项目。②在右侧【解决方案资源管理器中】，右键单击项目名称【ConsoleApp6】，依次点击【添加】→【类】，在弹出的【添加新项】窗口中，给类起一个名字Person.cs，然后点击【添加】。

第二步，编写人类：Person类添加成功后，系统会默认打开Person.cs文件，在该文件里声明一个Name属性、一个有参构造方法、一个虚方法Eat()

    class Person{public string Name { get; set; }//声明一个姓名属性public Person(string name)//声明一个有参构造方法{this.Name = name;}public virtual  void Eat()//使用virtual关键字，声明一个虚方法{Console.Write(this.Name+"来吃饭了！");}}

第三步，添加中国人类：在当前项目中添加一个中国人类Chinese，在系统会默认打开的Chinese.cs文件中，编写中国人类相关信息

    class Chinese : Person    //继承父类Person{public Chinese(string name) : base(name)    //使用base关键字调用父类的有参构造方法{}public override void Eat(){base.Eat();Console.WriteLine(this.Name+"是中国人，习惯用筷子吃饭");}}

第四步，添加美国人类：在当前项目中添加一个美国人类American，在系统会默认打开的American.cs文件中，编写美国人类相关信息

第五步，添加印度人类：在当前项目中添加一个印度人类Indian，在系统会默认打开的Indian.cs文件中，编写印度人类相关信息

第六步，在主程序中写代码：在Program.cs文件中的Main方法里，编写代码new一个集合，并添加数据，遍历输出集合里的数据。

预览效果：

        static void Main(string[] args){List<Person> persons = new List<Person>()//声明一个Person类型的集合，用初始化器批量添加数据{new Chinese("王迪"),           //new一个Chinese类的对象，王迪new American("jack"),         //new一个American类的对象，jacknew Indian("jhon")             //new一个Indian类的对象，jhon};foreach (Person outItem in persons)//将集合persons里的数据，遍历输出{outItem.Eat();//调用对象的Eat()方法}Console.ReadLine();}

代码分析：我们这里使用初始化器先初始化对象，然后初始化集合， new Chinese("王迪");将子类对象 赋值给父类对象时，子类对象会自动转换为父类对象，这个过程也叫“向上转型”。

接着我们将三个不 同类型的对象，添加到 Person 类型的泛型集合中，对集合进行遍历，调用所有对象的 Eat 方法。运行时 编译器会根据具体对象的类型，决定调用哪种 Eat()方法，从而实现了类的多态性。

3、使用new关键字实现多态

          有些情况下，我们只想在子类中定义一个名字和参数和父类一样的方法，但是又不想对父类方法进 行重写，又怎么办呢？ 可以使用 new 关键字，父类的方法不使用 virtual 或 abstract 定义，子类的方法前面加上 new。

示例练习2：使用new关键字实现多态（在示例1的基础上修改）

修改示例练习1：去掉 Person 类中的 virtual 关键字，将子类中的 override 改为 new。

运行结果图：

           我们看到最后调用的 Eat 方法是父类中的实现。也就是说 new 的作用是在子类中定义了一个新的方 法，没有覆盖父类的方法。那么这里为什么调用的是父类的方法，子类中的方法哪去了呢？因为我们定义对象类型是 Person 父类类型，所以调用的是父类的 Eat 方法，如果要调用子类的 Eat 方法，定义子类类型的对象就可以了。

American person2 = new American("奥巴马");
person2.Eat();

运行结果图： 

4、多态在方法中的应用（里氏替换原则）

          通过前面的示例我们知道：可以将子类对象转换为父类对象，也可以说子类对象可以替换父类对象， 但是反过来父类对象却不能替换子类对象，这种原则叫“里氏替换原则(Liskor Substitution Principle)”。

          我们在创建方法时，可以将参数定义成父类类型，而在调用方法时传入子类的对象，从而实现多态。

          以旅行为例，我们都知道旅行要乘坐交通工具 Vehicle，交通工具也有很多种类（汽车 Car、飞机 Plane、 轮船 Ship 等），游客 （ Traveler ）在开始旅行 （ Travel ）时，会由具体的交通工具运送 （ Transport ） 到目的地。

示例练习3：模拟旅行

第一步，新建项目：①在VS中新建控制台应用（.NET Framework），这里默认命名为【ConsoleApp6.1】，单击【确定】按钮，自动完成创建，并打开项目。②在右侧【解决方案资源管理器中】，右键单击项目名称【ConsoleApp6.1】，依次点击【添加】→【类】，在弹出的【添加新项】窗口中，给类起一个名字Vehicle.cs，然后点击【添加】。（同示例1的第一步相同）

第二步，编写交通工具类：Vehicle类添加成功后，系统会默认打开Vehicle.cs文件，在该文件里声明一个虚方法Transport()

    /// <summary>/// 交通工具类/// </summary>class Vehicle{//使用virtual关键字，声明一个虚方法Transport()public virtual void Transport(){Console.WriteLine("交通工具运送乘客出发了……");}}

第三步，添加汽车类：在当前项目中添加一个汽车类Car，在系统会默认打开的Car.cs文件中，使用override关键字重写父类的虚方法

    /// <summary>/// 汽车类/// </summary>class Car : Vehicle    //继承父类Vehicle{public override void Transport()      //使用override关键字，重写父类的虚方法{Console.WriteLine("汽车带你路上走");}}

第四步，添加飞机类：在当前项目中添加一个飞机类Plane，在系统会默认打开的Plane.cs文件中，使用override关键字重写父类的虚方法

第五步，添加轮船类：在当前项目中添加一个轮船类Ship，在系统会默认打开的Ship.cs文件中，使用override关键字重写父类的虚方法

第六步，添加旅行者类：在当前项目中添加一个旅行者类Traveler，在系统会默认打开的Traveler.cs文件中，声明一个旅行的方法Travel()，该方法需要传入一个参数，参数的数据类型是Vehicle（父类对象）

    /// <summary>/// 旅行者类/// </summary>class Traveler{//旅行public void Travel(Vehicle vehicle)     //  该方法需要传入参数，数据类型是Vehicle类型{Console.WriteLine("世界这么大，我要去看看");vehicle.Transport();    //调用对象的Transport()方法}}

第七步，在主程序中写代码：在Program.cs文件中的Main方法里，编写代码new一个旅行者对象，并调用方法。

        static void Main(string[] args){Traveler traveler = new Traveler();     //new一个旅行者对象//乘坐不同的交通工具traveler.Travel(new Car());     //调用旅行者对象的Trave方法，并将子类Car对象，作为参数传入traveler.Travel(new Plane());traveler.Travel(new Ship());Console.ReadLine();}

预览效果：

案例分析：我们看到旅行者对象调用旅行方法 Travel 时，传入了不同的交通工具对象，程序运行时根据具体的交通工具类型，执行了不同的运输方法，从而实现多态。

总结：使用虚方法实现多态的步骤：

1）将父类方法使用 virtual 定义为虚方法

2）在子类中使用 override 定义方法重写父类方法

3）使用子类时： ①将子类重写的方法参数定义为父类类型；②调用时传递子类对象（使用子类对象替换父类对象）

4）运行时程序会按具体子类类型，调用不同子类的方法

5、使用抽象类和抽象方法实现多态

在示例练习3中，我们定义了交通工具类：

    /// <summary>/// 交通工具类/// </summary>class Vehicle{//声明一个方法Transport()public virtual void Transport(){Console.WriteLine("交通工具运送乘客出发了……");}}

           交通工具类中的运送方法 Transport 有默认的实现，其实这个实现实际意义不大，因为交通工具是个抽象概念，不知道它是何种交通工具的情况下，是没办法进行具体的运送工作的。

           如果我们希望在父类中，只定义出某个方法，而不想实现它，把具体的实现交给它的子类去做，这种情况下我们就会使用抽象类和抽象方法。 

5.1  什么是抽象类、抽象方法

5.1.1  抽象类

概念：抽象类是表示抽象概念的特殊类。如果一个类不与具体的事物相联系，而只是表达一种抽象的概念，仅仅是作为派生类的一个基类，这样的类就是抽象类。抽象类使用关键字abstract来定义，抽象类不能被实例化，一个抽象类可以同时包含抽象方法和非抽象方法。比如说动物是抽象的，狗是具体的。

通俗理解：非常“抽象”的类。举个例子：生活中我们说院子里有只狗或猫，你会有一个概念，如果说有只动物就比较抽象了，如果说有个生物，那就更抽象了。

解释：经过多次抽象得到的类，一般是抽象类。这个类没有实例化的必要，不用new，用来做父类的。

语法：

//抽象类
[访问修饰符] abstract class 类名
{类成员
}

注意：

① 类一旦被定义成抽象类，那它就不能new了，它专门用来被继承（作为父类）。

② 抽象类不能是密封的或静态的（不能使用sealed或static关键字定义抽象类），因为定义密封类或静态类不能被子类继承，而不能被继承的抽象类是没有意义的。

③ 抽象类中依然可以正常的定义字段、属性、方法。

5.1.2  抽象方法

概念：在抽象类中也可以使用关键字absract定义抽象方法，要求所有的派生非抽象类都要重写实现抽象方法。引入抽象方法的原因在于抽象类本身是一种抽象概念，有的方法并不需要具体实现，而是留下来让派生类重写实现。抽象方法不能有方法体，抽象类中的所有抽象方法必须在子类中重写override。

语法：

//抽象方法
[访问修饰符] abstract 返回值类型 方法名(参数列表);

注意：

① 抽象方法不能声明方法体，用分号作为结束，不能有大括号{}。

② 抽象方法，只做声明，不做实现

③ 非抽象子类继承之后，必须强制重写父类的抽象方法。

④ 抽象方法只能放在抽象类中。

5.1.2  使用抽象类和抽象方法，实现多态

实现多态的步骤：

1）把父类定义成抽象类，需要被重写的方法，写成抽象方法

2）子类继承之后，重写父类的抽象方法，重写时加入子类自己的特性

5.2   抽象方法的应用

        抽象方法和虚方法都可以实现多态，那么什么情况下使用抽象方法呢？有时候父类中的某些方法的实现依赖于具体的子类类型，例如动物类有运动的方法，但是不知道具体是什么动物，无法定义出如何运动（是爬、是跳还是跑？）。这种情况下，我们就定义抽象方法来约束子类行为，由子类来具体实现方法。

示例练习4：模拟动物运动

第一步，新建项目：在VS中新建控制台应用（.NET Framework），这里默认命名为【ConsoleApp6.2】，单击【确定】按钮，自动完成创建，默认打开在Program.cs文件。（这里我们简化演示，将所有的类都写在Program.cs文件中。）

第二步，定义抽象类：在Program.cs文件中，使用abstract关键字定义一个抽象类Animal作为父类，在父类中定义一个抽象方法。

第三步，定义子类：在Program.cs文件中，定义三个子类：Dog、Bird、Fish，在子类中都必须重写父类的抽象方法，重写时，可以根据子类加入自己的特性。

第四步，在主程序中写代码：在Program.cs文件中的Main方法里，编写代码，new三个子类对象，并调用子类对象的方法。

运行效果：

关键代码：

namespace ConsoleApp6._2
{//使用abstract关键字，定义一个抽象类Animalabstract class Animal{public abstract void Move();        //定义一个抽象方法Move()，注意抽象方法没有方法体}//定义子类Dogclass Dog : Animal{public override void Move()         //重写父类的抽象方法{Console.WriteLine("小狗跑了起来");}}//定义子类Birdclass Bird : Animal{public override void Move(){Console.WriteLine("小鸟飞了起来");}}//定义子类Fishclass Fish : Animal{public override void Move(){Console.WriteLine("小鱼游了起来");}}class Program{static void Main(string[] args){Animal dog = new Dog();         //将子类对象new Dog()，赋值给父类对象Animal dogdog.Move();        //编译器根据具体对象的类型（子类Dog），决定调用那种Move方法Animal bird = new Bird();bird.Move();Animal fish = new Fish();fish.Move();Console.ReadLine();}}
}

6、虚方法和抽象方法比较

要实现多态时，用虚方法？还是抽象方法？

• 一般都是直接使用抽象类+抽象方法，实现多态。
• 虚方法本身有方法体，所以如果有共性操作，可以用虚方法。先放在父类的虚方法中，子类继承之后这部分代码可以复用。
• 需要定义抽象类，使用抽象方法，有强制约束的效果。

本课总结

•  面向对象中的多态，主要和对象的操作有关，不同的对象进行同一个操作时，可以有不同的实现方法。
•  C#中可以使用虚方法实现多态，首先我们将父类中的方法定义成虚（virtual）方法，在子类中 对父类的方法进行覆盖（override），也叫重写。
•  可以将子类对象转换为父类对象，也可以说子类对象可以替换父类对象，但是反过来父类对象 却不能替换子类对象，这种原则叫“里氏替换原则(Liskor Substitution Principle)”。
•  如果我们希望在父类中，只定义出某个方法，而不想实现它，把具体的实现交给它的子类去做， 这种情况下我们就会使用抽象类和抽象方法。
•  使用抽象类时要注意：
  •  抽象类不能实例化
  •  抽象类不能是密封的或静态的
•  面向对象三大特性：
  •  封装：保证对象自身数据的完整性和安全性
  •  继承：建立类之间的关系，实现代码重用，便于程序扩展
  •  多态：不同的子类对象调用相同的方法，有不同的实现方式

=============这里是结束分割线=================