面向对象三大特性之多态
多态是什么？
用一句话来概括下，多态就是同一操作（方法）作用于不同的对象时，可以有不同的解释，产生不同的执行结果。这句话看似简
单，实则颇有深意。下面我们来深入理解一多态的意义及如何使用多态。
使用多态编程的好处
在使用继承编程的时候，我们一般是把不同子类的方法分别写在不同的子类中，使用的时候用is a关键字来判断对象是哪种类型
的，然后进行强制转换来使用不同对象的方法。
但是，如果有多个子类的话，使用的时候难道要写多个if语句来判断对象是哪种类型的吗？这样会产生很多冗余代码，也会很繁
琐。
使用多态编程可以很好的解决这个问题。在父类写一个虚方法或抽象方法，子类去重写父类的方法，在调用的时候系统会根据对
象运行时的类型决定调用哪个方法。这样子是不是简洁多了？
小例子
假设我们有一个“书”类，然后有很多子类继承“书”类。例如“计算机组成原理”类继承“书类”，“深入Java面向对象”继承“书”类...
而这些子类都有类似的方法，即被不同的人使用。
下面我们来用代码实现它。
1 /// <summary> 2 /// 演示类 3 /// </summary> 4 class Demo 5 { 6 List<Book> books = new List<Book>(); 7 8 /// <summary> 9 /// 测试 10 /// </summary> 11 public void Test() 12 { 13 books.Add(new ComputerBook()); 14 books.Add(new JavaBook()); 15 16 foreach (Book item in books) 17 { 18 if (item is ComputerBook) 19 { 20 ((ComputerBook)item).ByReading(); 21 } 22 if (item is JavaBook) 23 { 24 ((JavaBook)item).ByReading(); 25 } 26 } 27 } 28 } 29 30 /// <summary> 31 /// 书类 32 /// </summary> 33 class Book 34 { 35 36 } 37 38 /// <summary> 39 /// 计算机书籍 40 /// </summary> 41 class ComputerBook : Book 42 { 43 /// <summary> 44 /// 被阅读 45 /// </summary> 46 public void ByReading() 47 { 48 Console.WriteLine("我是计算机类书籍，被在校大学生使用。"); 49 } 50 } 51 52 /// <summary> 53 /// Java书籍 54 /// </summary> 55 class JavaBook : Book 56 { 57 /// <summary> 58 /// 被阅读 59 /// </summary> 60 public void ByReading() 61 { 62 Console.WriteLine("我是Java书籍，被在业Java程序员使用。"); 63 } 64 }
通过这段代码可以发现：在使用子类对象的时候需要先用is a来判断子类对象时哪种类型的。那么也就是说，如果一个父类有10
个派生类（子类）的话，就要用10个if判断语句来判断子类对象是哪种类型了，未免太过繁琐。
这时，虚方法就该登场了。
虚方法
概念：
虚方法有方法体，可以被重写，使用virtual来修饰。
父类中的虚方法并非必须被子类重写，在父类中可以给出虚方法的默认实现。如果子类不重写父类的虚方法则依然执行
父类的默认实现。如果子类重写了父类的虚方法，则执行子类重写后的方法。
其实方法重载也是实现多态的一种形式，只是重载的方法都在同一个类中，而用虚方法实现多态的方法散布在有继承关
系的多个类中。
使用：
在父类中使用virtual关键字定义虚方法，在子类中使用override关键字来重写父类中的虚方法。
override关键字：
通过override关键字来修饰的方法，称为方法的重写。
下面我们用虚方法来改造一下上面的例子
1 /// <summary> 2 /// 演示类 3 /// </summary> 4 class Demo 5 { 6 List<Book> books = new List<Book>(); 7 8 /// <summary> 9 /// 测试 10 /// </summary> 11 public void Test() 12 { 13 books.Add(new ComputerBook()); 14 books.Add(new JavaBook()); 15 //遍历时不用加判断 16 foreach (Book item in books) 17 { 18 item.ByReading(); 19 } 20 } 21 } 22 23 /// <summary> 24 /// 书类 25 /// </summary> 26 class Book 27 { 28 public virtual void ByReading() 29 { 30 31 } 32 } 33 34 /// <summary> 35 /// 计算机书籍 36 /// </summary> 37 class ComputerBook : Book 38 { 39 /// <summary> 40 /// 被阅读 41 /// </summary> 42 public override void ByReading() 43 { 44 Console.WriteLine("我是计算机类书籍，被在校大学生使用。"); 45 } 46 } 47 48 /// <summary> 49 /// Java书籍 50 /// </summary> 51 class JavaBook : Book 52 { 53 /// <summary> 54 /// 被阅读 55 /// </summary> 56 public override void ByReading() 57 { 58 Console.WriteLine("我是Java书籍，被在业Java程序员使用。"); 59 } 60 }
可以看出，使用虚方法来写代码简便了许多。但是问题又来了，一般子类的父类和在父类中的虚方法是“宏观”的，“抽象”的，我
们不想让这个父类被实例化并且只提供方法的定义，由子类去实现这个方法，该怎么做呢？
如何解决这个问题呢？我们可以使用抽象类和抽象方法来实现。
抽象类和抽象方法
abstract关键字：
abstract关键字用来修饰抽象类和抽象方法。
抽象类：
使用abstract关键字修饰的抽象类不能被实例化。
抽象类中可以有非抽象方法。
抽象类不能是密封的或者静态的。
抽象方法：
使用abstract关键字修饰的抽象方法是一个没有实现的方法，由子类重写抽象方法来实现。
抽象方法没有大括号，直接在小括号后以分号";"结尾。
含有抽象方法的类必须是抽象类。
抽象方法必须在其子类中实现，除非它的子类也是抽象类。
下面我们使用抽象类和抽象方法再次改造上面的例子
1 /// <summary> 2 /// 演示类 3 /// </summary> 4 class Demo 5 { 6 List<Book> books = new List<Book>(); 7 8 /// <summary> 9 /// 测试 10 /// </summary> 11 public void Test() 12 { 13 books.Add(new ComputerBook()); 14 books.Add(new JavaBook()); 15 //遍历时不用加判断 16 foreach (Book item in books) 17 { 18 item.ByReading(); 19 } 20 } 21 } 22 23 /// <summary> 24 /// 书类 25 /// </summary> 26 abstract class Book 27 { 28 public abstract void ByReading(); 29 } 30 31 /// <summary> 32 /// 计算机书籍 33 /// </summary> 34 class ComputerBook : Book 35 { 36 /// <summary> 37 /// 被阅读 38 /// </summary> 39 public override void ByReading() 40 { 41 Console.WriteLine("我是计算机类书籍，被在校大学生使用。"); 42 } 43 } 44 45 /// <summary> 46 /// Java书籍 47 /// </summary> 48 class JavaBook : Book 49 { 50 /// <summary> 51 /// 被阅读 52 /// </summary> 53 public override void ByReading() 54 { 55 Console.WriteLine("我是Java书籍，被在业Java程序员使用。"); 56 } 57 }
到了这里，我们可以发现使用虚方法和抽象方法来编程（也就是多态）更符合面向对象编程的思想，并且可以大幅的提升代码的
可读性和减少冗余的代码。
用更少的代码实现相同的实现，这感觉，很爽的。
